Attendez que deux threads se terminent

Question

Si vous avez un thread principal qui démarre deux autres threads. Quelle est la manière la plus propre de faire attendre le thread primaire pour les deux autres threads?

Je pourrais utiliser bgndworker et sleep spinner qui vérifie les deux IsBusy des travailleurs de bgnd, mais je pense qu'il y a une meilleure façon.

EDIT Quelques autres exigences:

• Le fil conducteur a un autre travail à faire (par exemple GUI).
• Les deux fils donné naissance devraient pouvoir signaler les exceptions et retour résultat valeurs

Answer 1

Voir les réponses au this thread. J'aime this option ;-P

Forker p = new Forker(); 
p.Fork(delegate { DoSomeWork(); }); 
p.Fork(delegate { DoSomeOtherWork(); }); 
p.Join(); 

Re retour valeurs/exceptions de rapports - juste avoir chaque fourche faire cela comme un rappel à la fin de la logique ... (vous pouvez utiliser des variables capturées pour passer l'état à la fois la fourches, y compris un enregistreur partagé, etc.).

Answer 2

WaitHandle.WaitAny est votre ami. Il vous permet d'attendre sur plusieurs threads ou d'autres types d'objets à signaler.

http://msdn.microsoft.com/en-us/library/tdykks7z.aspx

EDIT:

En fait, WaitHandle.WaitAll est ce que vous voulez, pas WaitAny.

http://msdn.microsoft.com/en-us/library/system.threading.waithandle.waitall.aspx

EDIT:

La méthode join une mention est ok, mais un inconvénient est que ce n'est pas une opération complètement atomique. Cela peut ou peut ne pas être important pour vous, cependant.

Answer 3

thread1.Join(); 
thread2.Join(); 

Answer 4

Exemple rapide utilisant Thread.Join();

 Thread t1 = new Thread(new ThreadStart(delegate() 
     { 
      System.Threading.Thread.Sleep(2000); 
     })); 

     Thread t2 = new Thread(new ThreadStart(delegate() 
     { 
      System.Threading.Thread.Sleep(4000); 
     })); 

     t1.Start(); 
     t2.Start(); 

     t1.Join(); 
     t2.Join(); 

EDIT Une autre 3example en utilisant Wait Poignées:

  ManualResetEvent[] waitHandles = new ManualResetEvent[]{ 
      new ManualResetEvent(false), 
      new ManualResetEvent(false) 
     }; 

     Thread t1 = new Thread(new ParameterizedThreadStart(delegate(object state) 
     { 
      ManualResetEvent handle = (ManualResetEvent)state; 
      System.Threading.Thread.Sleep(2000); 
      handle.Set(); 
     })); 

     Thread t2 = new Thread(new ParameterizedThreadStart(delegate(object state) 
     { 
      ManualResetEvent handle = (ManualResetEvent)state; 
      System.Threading.Thread.Sleep(4000); 
      handle.Set(); 
     })); 

     t1.Start(waitHandles[0]); 
     t2.Start(waitHandles[1]); 

     WaitHandle.WaitAll(waitHandles); 

     Console.WriteLine("Finished"); 

Answer 5

En plus des autres réponses ... une alternative à "commencer à deux fils et d'attendre les deux à la fin" est « start un thread et effectuez vous-même un travail, puis attendez que l'autre thread se termine ".

Bien sûr, si vous voulez démarrer deux tâches, travaillez plus sur le thread principal et puis attendez que les deux autres threads se terminent, cela ne fonctionne pas très bien.

EDIT: Si le thread principal est un thread UI, vous ne devriez pas bloquer sur les autres threads de finition - vous devriez (IMO) les amener à rappeler au thread principal quand ils ont fini. De cette façon, vous aurez toujours une interface utilisateur réactive pendant l'exécution.

Answer 6

Vous ne pouvez pas attendre la fin et avoir GUI utilisable. La meilleure approche consiste à générer des threads et à utiliser des événements pour communiquer avec l'interface graphique. Souvenez-vous que dans le gestionnaire d'événements, vous ne pouvez pas modifier le contrôle. Plutôt que de le faire directement, utilisez la méthode Invoke.