Déterminer si tous les threads ont fini c#

La façon de le faire serait de garder une référence pour tous les threads et puis Rejoindre sur eux. Cela signifie essentiellement que le thread en cours bloquera jusqu'à ce que le joint thread se termine.

Changer votre boucle à quelque chose comme:

foreach (string ws in machineList)
{
   var thread = new Thread(new ParameterizedThreadStart(fixClient), stack);
   _machineThreads.Add(thread)
   thread.Start();
}

(où _machineThreads est une liste de System.Thread)

Vous pouvez bloquer jusqu'à ce que tous sont complets avec quelque chose comme:

private void WaitUntilAllThreadsComplete()
{
   foreach (Thread machineThread in _machineThreads)
   {
      machineThread.Join();
   } 
}

CEPENDANT - vous avez presque certainement ne voulez pas faire cela pour le scénario que vous décrivez:

• Vous ne devriez pas créer un grand nombre de threads explicitement la création de centaines de threads n'est pas une bonne idée
• Vous devriez préférer d'autres approches - essayez de regarder En parallèle.ForEach et Système.Le filetage.Tâche. Ces jours-ci, .Net vous donne beaucoup d'aide quand vous travaillez avec filetage et de tâches asynchrones - vraiment, je vous conseille de lire plutôt que d'essayer de "rouler" avec leur fils.
• Cela ressemble à un gestionnaire de clic. Est-il ASP.NET des formulaires web, ou une application de bureau? Dans le premier cas, je ne voudrais certainement pas conseiller de frai beaucoup de threads pour effectuer les tâches d'arrière-plan à partir de la demande. Dans les deux cas, voulez-vous vraiment votre page web ou l'interface utilisateur de bloquer pendant l'attente des threads pour achever?

OriginalL'auteur Rob Levine

Une autre idée serait d'utiliser en Parallèle.ForEach dans un autre thread:
C'est également sans danger si vous avez trop beaucoup de machines, pour résoudre

private void repairClientsToolStripMenuItem_Click(object sender, EventArgs e)
{

    if (machineList.Count() != 0)
    {
        AllFinished=False;
        new Thread(new ThreadStart(fixAllClients).Start();
    }
    else
    {
         MessageBox.Show("Please import data before attempting this procedure");
    }
}

private void fixAllClients(){
    var options = new ParallelOptions{MaxDegreeOfParallelism=10};
    Parallel.ForEach(machineList. options, fixClient);
    AllFinished=True;
}

OriginalL'auteur weismat

Il est une autre façon de faire qui utilise le CountdownEvent classe.

Le code qui commence le fils doit incrémenter un compteur, et passer un CountdownEvent objet à chaque thread. Chaque thread va appeler CountdownEvent.Signal() quand c'est fini.

Le code suivant illustre cette approche:

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication6
{
    class Program
    {
        static void Main(string[] args)
        {
            int numTasks = 20;
            var rng = new Random();

            using (var finishedSignal = new CountdownEvent(1))
            {
                for (int i = 0; i < numTasks; ++i)
                {
                    finishedSignal.AddCount();
                    Task.Factory.StartNew(() => task(rng.Next(2000, 5000), finishedSignal));
                }

                //We started with a count of 1 to prevent a race condition.
                //Now we must decrement that count away by calling .Signal().

                finishedSignal.Signal(); 
                Console.WriteLine("Waiting for all tasks to complete...");
                finishedSignal.Wait();
            }

            Console.WriteLine("Finished waiting for all tasks to complete.");
        }

        static void task(int sleepTime, CountdownEvent finishedSignal)
        {
            Console.WriteLine("Task sleeping for " + sleepTime);
            Thread.Sleep(sleepTime);
            finishedSignal.Signal();
        }
    }
}

OriginalL'auteur Matthew Watson

Laissez-nous obtenir quelque chose hors de la voie d'abord.

• Ne pas créer de threads individuels pour cela. Les Threads sont une ressource coûteuse. Au lieu de cela utiliser le thread techniques de regroupement.
• Ne pas bloquer le thread d'INTERFACE utilisateur en appelant Thread.Join, WaitHandle.WaitOne, ou de tout autre mécanisme de blocage.

Ici est de savoir comment je le faire avec le TPL.

private void repairClientsToolStripMenuItem_Click(object sender, EventArgs e) 
{ 
  if (machineList.Count() != 0) 
  { 
    //Start the parent task.
    var task = Task.Factory.StartNew(
      () =>
      {
        foreach (string ws in machineList)
        {
          string capture = ws;
          //Start a new child task and attach it to the parent.
          Task.Factory.StartNew(
            () =>
            {
              fixClient(capture);
            }, TaskCreationOptions.AttachedToParent);
        }
      }, TaskCreationOptions.LongRunning);

    //Define a continuation that happens after everything is done.
    task.ContinueWith(
      (parent) =>
      {
        //Code here will execute after the parent task including its children have finished.
        //You can safely update UI controls here.
      }, TaskScheduler.FromCurrentSynchronizationContext);
  } 
  else 
  { 
    MessageBox.Show("Please import data before attempting this procedure"); 
  } 
} 

Ce que je fais ici est la création d'un parent tâche qui va lui-même faire tourner des tâches enfants. Notez que j'utilise TaskCreationOptions.AttachedToParent associer à l'enfant des tâches avec leur parent. Puis sur la tâche parente j'appelle ContinueWith qui est exécuté après la mère et de tous ses enfants ont terminé. J'utilise TaskScheduler.FromCurrentSynchronizationContext pour obtenir la poursuite d'arriver sur le thread d'INTERFACE utilisateur.

Et voici une autre solution à l'aide de Parallel.ForEach. Remarquez que c'est un peu la solution de nettoyage.

private void repairClientsToolStripMenuItem_Click(object sender, EventArgs e) 
{ 
  if (machineList.Count() != 0) 
  { 
    //Start the parent task.
    var task = Task.Factory.StartNew(
      () =>
      {
        Parallel.Foreach(machineList,
          ws =>
          {
            fixClient(ws);
          });
      }, TaskCreationOptions.LongRunning);

    //Define a continuation that happens after everything is done.
    task.ContinueWith(
      (parent) =>
      {
        //Code here will execute after the parent task has finished.
        //You can safely update UI controls here.
      }, TaskScheduler.FromCurrentSynchronizationContext);
  } 
  else 
  { 
    MessageBox.Show("Please import data before attempting this procedure"); 
  } 
} 

OriginalL'auteur Brian Gideon