如何等待所有后台线程完成（在C＃中）？

Question

如何让前台线程等待所有后台（子）线程在C＃中完成？我需要从队列（数据库）中获取待处理作业的列表，启动一个新线程来执行它们中的每一个，并最终等待所有子线程完成。如何在C＃中做到这一点？提前致谢。

Answer 1

考虑使用线程池。你想要的大部分已经完成了。有一个example from Microsoft它几乎完成你的整个任务。将“fibonacci”替换为“数据库任务”，听起来像是你的问题。

Answer 2

您可以将每个启动的线程存储在一个数组中。然后当你需要等待它们全部时，在循环中的数组中的每个线程上调用Join方法。

Thread child = new Thread(...); 
Threads.Add(child); 
child.Start() 

... 

foreach(Thread t in Threads) 
{ 
    t.Join(); 
} 

HTH

Answer 3

这是不完整的代码，但ManualResetEvent为你的作品

var waitEvents = new List<ManualResetEvent>(); 
foreach (var action in actions) 
{ 
    var evt = new ManualResetEvent(false); 
    waitEvents.Add(evt); 
    ThreadPool.RegisterWaitForSingleObject(asyncResult.AsyncWaitHandle, TimeoutCallback, state, 5000, true); 
} 

if (waitEvents.Count > 0) 
    WaitHandle.WaitAll(waitEvents.ToArray()); 

Answer 4

创建一个结构，让您的工作线程的跟踪

private struct WorkerThreadElement 
{ 
    public IAsyncResult WorkerThreadResult; 
    public AsyncActionExecution WorkerThread; 
} 

您还需要跟踪预期要创建的线程总数以及当前有多少个线程完成

private int _TotalThreads = 0; 
private int _ThreadsHandled = 0; 
private List<WorkerThreadElement> _WorkerThreadElements = new List<WorkerThreadElement>(); 

然后创建一个自动复位句柄以等待线程完成。

// The wait handle thread construct to signal the completion of this process 
private EventWaitHandle _CompletedHandle = new AutoResetEvent(false); 

你还需要一个委托创建新主题 - 这样做有多种方式，但我选择了一个简单的委托为这个例子的目的

// Delegate to asynchronously invoke an action 
private delegate void AsyncActionExecution(); 

让asume的Invoke方法是创建所有线程并等待其执行的入口点。所以我们有：

public void Invoke() 
{ 
    _TotalThreads = N; /* Change with the total number of threads expected */ 

    foreach (Object o in objects) 
    { 
     this.InvokeOneThread(); 
    }    

    // Wait until execution has been completed 
    _CompletedHandle.WaitOne(); 

    // Collect any exceptions thrown and bubble them up 
    foreach (WorkerThreadElement workerThreadElement in _WorkerThreadElements) 
    { 
     workerThreadElement.WorkerThread.EndInvoke(workerThreadElement.WorkerThreadResult); 
    } 
}   

InvokeOneThread是用于为一个操作创建单个线程的方法。这里我们需要创建一个工作线程元素并调用实际的线程。从线程完成

private void InvokeOneThread() 
{ 
    WorkerThreadElement threadElement = new WorkerThreadElement(); 
    threadElement.WorkerThread = new AsyncActionExecution(); 
    threadElement.WorkerThreadResult = threadElement.WorkerThread.BeginInvoke(actionParameters, InvokationCompleted, null); 

    _WorkerThreadElements.Add(threadElement); 
} 

回调

private object _RowLocker = new object(); 

/// <summary> 
/// Increment the number of rows that have been fully processed 
/// </summary> 
/// <param name="ar"></param> 
private void InvokationCompleted(IAsyncResult ar) 
{ 
    lock (_RowLocker) 
    { 
     _RowsHandled++; 
    } 

    if (_TotalThreads == _ThreadsHandled) 
     _CompletedHandle.Set(); 
} 

完成

Answer 5

使用动态数据，你可以通过你的对象和WaitHandle的（ActionResetEvent），让你等待所有的后台线程完成不宣而一个额外的类：[C＃产生多个线程的

static void Main(string[] args) 
{ 
    List<AutoResetEvent> areList = new List<AutoResetEvent>(); 
    foreach (MyObject o in ListOfMyObjects) 
    { 
     AutoResetEvent are = new AutoResetEvent(false); 
     areList.Add(are); 
     ThreadPool.QueueUserWorkItem(DoWork, new { o, are }); 
    }; 

    Console.WriteLine("Time: {0}", DateTime.Now); 
    WaitHandle.WaitAll(areList.ToArray()); 
    Console.WriteLine("Time: {0}", DateTime.Now); 
    Console.ReadKey(); 
} 

static void DoWork(object state) 
{ 
    dynamic o = state; 
    MyObject myObject = (MyObject)o.o; 
    AutoResetEvent are = (AutoResetEvent)o.are; 

    myObject.Execute(); 
    are.Set(); 
}