Attendre QueueUserWorkItem pour Compléter

Si j'ajoute des emplois pour le pool de threads avec QueueUserWorkItem... comment faire pour garder mon programme d'aller de l'avant jusqu'à ce que tous les travaux sont terminés?

Je sais que je pourrais ajouter un peu de logique pour garder l'application de s'exécuter jusqu'à ce que toutes les tâches sont terminées, mais je veux savoir si il y a quelque chose comme Thread.Join() ou si il y a moyen de récupérer chaque thread qui est affecté à un emploi.

La version de .NET vous aide?
.net version 2.0

OriginalL'auteur PedroC88 | 2011-06-30

  1. 41

    Vous pouvez utiliser les événements de synchronisation. Comme ceci:

    private static ManualResetEvent resetEvent = new ManualResetEvent(false);

public static void Main()
{
    ThreadPool.QueueUserWorkItem(arg => DoWork());
    resetEvent.WaitOne();
}

public static void DoWork()
{
    Thread.Sleep(5000);
    resetEvent.Set();
}

    Si vous ne voulez pas intégrer événement dans votre méthode, vous pourriez faire quelque chose comme ceci:

    var resetEvent = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(
    arg => 
    {
        DoWork();
        resetEvent.Set();
    });
resetEvent.WaitOne();

    Pour plusieurs éléments:

    var events = new List<ManualResetEvent>();

foreach(var job in jobs)
{   
    var resetEvent = new ManualResetEvent(false);
    ThreadPool.QueueUserWorkItem(
        arg =>
        {
            DoWork(job);
            resetEvent.Set();
        });
    events.Add(resetEvent);
}
WaitHandle.WaitAll(events.ToArray());
    Ce serait facile de travailler pour les les d'attente d'un emploi à un moment... mais Si j'ai eu plusieurs emplois alors j'aurais besoin d'une boucle de contrôle? N'aurais-je pas? Sinon... Comment est-ce adaptable à de multiples travaux en file d'attente?
    mise à jour de la réponse.
    cela a une limite de 64 éléments. Comme les autres réponses indiquent qu'il y a de plus adapté construit pour faire face à de multiples tâches, mais si vous ciblez les anciens profils, vous pouvez utiliser un seul événement et l'utilisation d'un compteur décrémenté avec Interloqué.Décrémenter

    OriginalL'auteur Alex Aza

  2. 16

    La meilleure façon de le faire est d'utiliser la CountdownEvent classe. C'est assez bien établi motif, et qui est aussi évolutif qu'il obtient.

    using (var finished = new CountdownEvent(1))
{
  foreach (var workitem in workitems)
  {
    var capture = workitem; //Used to capture the loop variable in the lambda expression.
    finished.AddCount(); //Indicate that there is another work item.
    ThreadPool.QueueUserWorkItem(
      (state) =>
      {
        try
        {
          ProcessWorkItem(capture);
        }
        finally
        {
          finished.Signal(); //Signal that the work item is complete.
        }
      }, null);
  }
  finished.Signal(); //Signal that queueing is complete.
  finished.Wait(); //Wait for all work items to complete.
}
    C'est la grande solution, malheureusement il ne fonctionne que dans .NET 4.
    Excellente réponse! Mais comment pourrais-je être en mesure d'annuler les fils prématurément avec CountdownEvent? Comme si j'étais l'utilisation de ce dans une application Windows Forms et l'utilisateur ferme le formulaire, mais il y a des threads en cours d'exécution.
    Cette réponse est un peu dépassé. Plus contemporain solution est d'utiliser la Task Parallel Library pour des trucs comme ça. De toute façon, inclus dans le TPL est la coopérative d'annulation de cours. C'est ce qui devrait être utilisé pour se terminer normalement threads.

    OriginalL'auteur Brian Gideon

  3. 3

    Vous pouvez utiliser .NET Barrière classe pour atteindre cet objectif.

    Barrier barrier = new Barrier(3); 
for(int i = 0; i < 2; i++)
{
    ThreadPool.QueueUserWorkItem(
    (state) =>
    {
       foo();
       barrier.SignalAndWait();
    }, null);
}
barrier.SignalAndWait();
    DrewR, pouvez-vous donner un exemple qui répond à la question?
    J'ai ajouté un exemple - note .NET 4 fonction

    OriginalL'auteur Drew R