Espere hasta que todas las discusiones terminaron su trabajo en ThreadPool

Question

tengo este código:

var list = new List<int>(); 
for(int i=0;i<10;i++) list.Add(i); 
for(int i=0;i<10;i++) 
{ 
    ThreadPool.QueueUserWorkItem(
     new WaitCallback(x => { 
      Console.WriteLine(x); 
     }), list[i]); 
} 

Y quiero saber cuando todas las discusiones threadpools terminaron su trabajo. ¿Cómo puedo hacer eso?

Answer 1

Tendrá que hacer un seguimiento de esto usted mismo.

Una opción para esto es utilizar un contador y un evento de reinicio:

int toProcess = 10; 
using(ManualResetEvent resetEvent = new ManualResetEvent(false)) 
{ 
    var list = new List<int>(); 
    for(int i=0;i<10;i++) list.Add(i); 
    for(int i=0;i<10;i++) 
    { 
     ThreadPool.QueueUserWorkItem(
      new WaitCallback(x => { 
       Console.WriteLine(x); 
       // Safely decrement the counter 
       if (Interlocked.Decrement(ref toProcess)==0) 
       resetEvent.Set(); 

      }),list[i]); 
    } 

    resetEvent.WaitOne(); 
} 
// When the code reaches here, the 10 threads will be done 
Console.WriteLine("Done"); 

Answer 2

No estoy seguro de si ThreadPool expone dicha funcionalidad, pero se puede utilizar espere asas y por la forma en la iteración en dos ocasiones parece innecesario:

var events = new ManualResetEvent[10]; 
var list = new List<int>(); 
for (int i = 0; i < 10; i++) 
{ 
    list.Add(i); 
    events[i] = new ManualResetEvent(false); 
    int j = i; 
    ThreadPool.QueueUserWorkItem(x => { 
     Console.WriteLine(x); 
     events[j].Set(); 
    }, list[i]); 
} 
WaitHandle.WaitAll(events); 

Answer 3

El grupo de subprocesos no indica cuándo el subproceso ha terminado de ejecutarse, por lo que el elemento de trabajo debe hacerlo por sí mismo. Cambié el código de esta manera:

var list = new List<int>(); 
    ManualResetEvent[] handles = new ManualResetEvent[10]; 
    for (int i = 0; i < 10; i++) { 
     list.Add(i); 
     handles[i] = new ManualResetEvent(false); 
    } 
    for (int i = 0; i < 10; i++) { 
     ThreadPool.QueueUserWorkItem(
     new WaitCallback(x => 
     { 
      Console.WriteLine(x); 
      handles[(int) x].Set(); 
     }), list[i]); 
    } 

    WaitHandle.WaitAll(handles); 

Answer 4

Así es como lo haría.

class Program 
{ 
    static void Main(string[] args) 
    { 
     var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
     using (var countdown = new Countdown(items.Length)) 
     { 
      foreach (var item in items) 
      { 
       ThreadPool.QueueUserWorkItem(o => 
       { 
        Thread.SpinWait(100000000); 
        Console.WriteLine("Thread Done!"); 
        countdown.Signal(); 
       }); 
      } 
      countdown.Wait(); 
     } 
     Console.WriteLine("Job Done!"); 
     Console.ReadKey(); 
    } 

    public class Countdown : IDisposable 
    { 
     private readonly ManualResetEvent done; 
     private readonly int total; 
     private volatile int current; 

     public Countdown(int total) 
     { 
      this.total = total; 
      current = total; 
      done = new ManualResetEvent(false); 
     } 

     public void Signal() 
     { 
      lock (done) 
      { 
       if (current > 0 && --current == 0) 
        done.Set(); 
      } 
     } 

     public void Wait() 
     { 
      done.WaitOne(); 
     } 

     public void Dispose() 
     { 
      done.Dispose(); 
     } 
    } 
} 

Answer 5

En .NET Framework 4+ utilizan la práctica de clase System.Threading.CountdownEvent:

const int threadCount = 10; 
var list = new List<int>(threadCount); 
for (var i = 0; i < threadCount; i++) list.Add(i); 

using (var countdownEvent = new CountdownEvent(threadCount)) 
{ 
    for (var i = 0; i < threadCount; i++) 
     ThreadPool.QueueUserWorkItem(
      x => 
      { 
       Console.WriteLine(x); 
       countdownEvent.Signal(); 
      }, list[i]); 

    countdownEvent.Wait(); 
} 
Console.WriteLine("done");