MultithreadRésolu

Question

Bonjour, j'arrive a developper un programme compresseur de données qui peut compresser n'import q'elle taille dans moins de 2 kilos, mais le problem est que le temps d'execution pour un fichier de 10 mega est trops (>10 munites), je veus s'avoir comment lire ou ecrire dans un fichier avec plusieur processus (comment gérer la multithreading)
merci

SamirAloui · Accepted Answer

Merci boucoup, et de mon tour je te promet si j'arrive à optimiser mon compresseur je t'envoie une copie (mais pas la source) gratuitement, et j'espere q'il va faire une grande chose dans le monde de compression de donne   Merci encore

pymaster · Answer

Bonjour

Si tu ne veux pas te lancer dans trop compliqué il existe dans Vs2005 un control "Background Worker" (regarde dans "tous les Windows Form" dans la barre d'outils )
Un backgroundWorder c'est un thread mais dont la plupart de la gestion est fait pour toi. Tu créé l'objet et tu place ton code dans l'évènement DoWork du controle.

Pour en créer un à partir du code tu peux faire :
 
   Private bwTest As System.ComponentModel.BackgroundWorker = Nothing
        Me.bwTest = New System.ComponentModel.BackgroundWorker()
        
        bwTest.WorkerSupportsCancellation = True
        AddHandler bwSavePhoto.DoWork, AddressOf bwTest_DoWork
        AddHandler bwSavePhoto.RunWorkerCompleted, AddressOf bwTest_RunWorkerCompleted
        bwTest.RunWorkerAsync() 
        
        note : il faut que les fonctions bwTest_DoWork et bwTest_RunWorkerCompleted existe déjà et qu'elle est la signature 
        
private sub bwTest_DoWork(ByVal sender As Object, ByVal e As System.ComponentModel.DoWorkEventArgs)
        
        et
        
Private Sub bwTest_RunWorkerCompleted(ByVal sender As Object, ByVal e As System.ComponentModel.RunWorkerCompletedEventArgs) Handles bwSavePhoto.RunWorkerCompleted

Voila, pour ce qui est des objets Threads alors c'est beaucoup plus complexe, mais si le Backgroundworker ne suffit pas je pourrais t'expliquer

PY

SamirAloui · Answer

Merci, mais pas ça que je veus Mon pbm est que je veus une architecture de (Pproducteur / Consomateur) c-a-d que ma methode de compression:

Utilise la notions des couche
Chaque couche utilise des informations en entree, et genere des infos en sortie
les infos de sortie de chaque couche seront les infos d'entree de couche suivante.
Apres une quantité constante d'information de sortie, la couche suivante peut etre activée (un genre de parallellisme)
Une fois les infos d'entrée sont utilisées, en peut les supprimer (Vider la RAM)

Alors je veus effectuer chaque couche à un processus (Tâche OU Thread) pour : - Accélérer le temps d'execution - Gagner l'espace mémoire Le probleme est que je veus connetre comment: 1-Creer plusieur processus et les synchroniser 2-Partager une ressource (zone mémoire / fichier) entre plusieur processus (Probleme de Lecteur/Redacteur) Merci

pymaster · Answer

Rebonjour !


Ok, à ce moment la tu a vraiment besoin de l'objet Thread


Pour un exemple tu peux regarder ma source ici
J'utilse 2 Thread pour afficher mon images avec des files d'attente partage d'information par file et tableau et tout ce dont tu à de besoin



http://www.vbfrance.com/listeauteur2.aspx?ID=820468




Pour Utiliser des Threads comme tu veux le faire tu va avoir besoins de Mutex et Semaphore. Ce sont des objets servant à faire la Synchronisation des Threads


En .NET pour partager des variables entres plusieurs Threads tu dois les déclarer Shared, ainsi chaque Threads accèderas à la même instance de la variable. 


Dans ton cas pour synchroniser chacune de tes couches utilse les Semaphores. Les sémaphore limite l'accès d'une ressource, dans ton cas la ressource c'est ton Thread. Si tu fait maSemaphore.WaitOne() le Thread sera mis en attente jusqu'a ce qu'un autre Thread fasse maSemaphore.ReleaseOne.

Note : On attribu une valeur à la création d'une sémaphore example



Private Shared sSemaFile As New Semaphore(0, 1)


le 0 veux dire que le semaphore commence avec 0 accès permis et 1 veux dire qu'il ne peux pas permettre plus que 1 accès
Ce qui veux dire que quand tu fait sSemafile.Release() le premier coup la valeur de ton sémaphore est rendu à 1 accèss permis, si un Thread a ce moment la était en attente d'un accès alors il le prendra et la valeur reviedra à 0 accès permis. 
Note : Il ne faut pas faire plus de release que de Wait() sinon c'est une erreur 


Exemple : 



private shared sSema as Semaphore



private codeDeMonThreads1
 while(1)
   Code ..
   ' Lorsqu'il y a assez d'info
   sSema.Release() ' Averti l'autre Thread qu'il peut démarer
  end while 
End Private





Private sub codeDeMonThreads2



 while(1) 
   sSema.WaitOne ' En attente d'un relase
 
   code ...
   
   ' Si on doit encore faire du code
   sSema.Release
   ' Sinon on retourne en wait 
   end while
 end sub
 
 Voila, l'exemple est très simple, mais je pense que c'est en regardant mon code complet que tu va vraiment pouvoir apprendre de quoi 

Les Threads c'est vraiment pas facile, si t'as encore besoin d'aide hesite pas ! 
Bonne chance , 
PY

pymaster · Answer

Autres choses que j'ai oubliés

Premièrement tu es mieux avec des Threads qu'avec des processus ( ce n'est pas la même chose  ) 

Pour créé un Thread du déclare

    Private nomDuThread As New Thread(AddressOf fonctionDuThreads)

Pour partir un Thread du fait 

nomDuThread.start()

Pour l'arrêter tu fais

nomDuThread.Abort()

Pour attendre qu'il soit vraiment arrêté du fait

nomDuThread.Join()

Voila, je pense que c'est pas mal tout, 
PY

Multithread

5 réponses

Votre réponse

Discussions similaires