如何停止一个线程，直到n个线程完成其工作

Question

我有一个主线程的应用程序和N工作线程。在某些时候，我需要主线程等待，直到所有的线程完成其工作的一部分。

我通常会使用Monitor.Wait（）和Monitor.Pulse（），但这会阻止线程同时工作。

任何想法如何做到这一点？

在此先感谢。

Answer 1

好吧，我现在做（使用你的想法），并似乎工作是这样的：

我宣布ManualResetEvent的列表：

Private m_waitHandles As List(Of Threading.ManualResetEvent) 

该进程接受传入的Tcp连接并在每个连接上启动一个线程。因此，在新的客户端处理程序我已经添加以下代码：

Dim waitHandle As Threading.ManualResetEvent 
waitHandle = New Threading.ManualResetEvent(True) 
SyncLock (DirectCast(m_waitHandles, IList).SyncRoot) 
    m_waitHandles.Add(waitHandle) 
End SyncLock 

''# Do all the work 
StoppableMethod() 

SyncLock (DirectCast(m_waitHandles, IList).SyncRoot) 
    waitHandle = m_waitHandles.Item(Threading.WaitHandle.WaitAny(m_waitHandles.ToArray())) 
End SyncLock 

waitHandle.Reset() 
NonStoppableMethod() 
waitHandle.Set() 

SyncLock (DirectCast(m_waitHandles, IList).SyncRoot) 
    m_waitHandles.Remove(waitHandle) 
End SyncLock 

做的最后一件事是修改Stop方法，以确保停止操作不会与NonStoppableMethod内的任何线程中完成的：

SyncLock (DirectCast(m_waitHandles, IList).SyncRoot) 
    If m_waitHandles.Count > 0 Then 
     Threading.WaitHandle.WaitAll(m_waitHandles.ToArray()) 
    End If 
End SyncLock 

我不确定这是否以正确的方式完成，因为这是我第一次处理这样的事情。你觉得这是好的，是一个好方法吗？

感谢所有，配偶！

Answer 2

这就是所谓的一个障碍：http://programmingexamples.wikidot.com/java-barrier

嗷，但如果你只需要第一个线程等待其余通过某些时候，你想让对方依然继续工作，然后用大小为N的信号让所有其他线程需要它，而第一个线程等待后，他们获得它..

信号灯：http://programmingexamples.wikidot.com/java-semaphore

Answer 3

如果你只需要等待，直到线程终止，怎么样Thread.Join？在.NET 4.0中，您可以使用Task.WaitAll。如果你需要等到他们完成任务的一部分，这是一个小窍门。在当前版本的.NET中，请看WaitHandle.WaitAll/Threading.ManualResetEvent。在.NET 4.0中，您可以使用Threading.Barrier。

Answer 4

做一些类似垃圾收集。您将编写一个ThreadManager，其中有多少个线程正在运行。当主线程启动一个新工作者时，ThreadManager将增加工作者的数量。当工作完成时，它会通知ThreadManager谁将递减其线程数。当它有零个工作线程时，ThreadManager将唤醒主线程。

Answer 5

.NET 4.0将包括System.Threading.Barrier类，它将使多个线程之间的同步更容易。有一些很好的示例代码的博客帖子可以找到here。

Similar functionality can be achieved在.NET 3.0+中使用多个WaitHandles，如在MSDN上的this example中所示。

MSDN的例子的小结：

const int numberOfWorkers = 5; 

static void Main() 
{ 
    var handles = new ManualResetEvent[numberOfWorkers]; 

    for (int i = 0; i < numberOfWorkers; i++) 
    { 
     handles[i] = new ManualResetEvent(false); 
     ThreadPool.QueueUserWorkItem(o => worker.Work(), null); 
    } 

    // Wait for all workers to finish before continuing 
    WaitHandle.WaitAll(handles); 
    /* continue execution... */ 
} 

Answer 6

由于在一些实现，有多少把手WaitHandle.WaitAll()可以....处理，（见msdn-WaitHandle.WaitAll()的限制，我创建了一个实用方法为此：

public static void WaitAll(WaitHandle[] handles) 
    { 
     if (handles == null) 
      throw new ArgumentNullException("handles", 
       "WaitHandle[] handles was null"); 
     foreach (WaitHandle wh in handles) wh.WaitOne(); 
    } 

用法是添加等待句柄每个线程的阵列，然后调用上述工具方法（传递数组）的所有线程已经启动之后

。

List<WaitHandle> waitHndls = new List<WaitHandle>(); 
foreach (MyType mTyp in MyTypeCollection) 
{ 
    ManualResetEvent txEvnt = new ManualResetEvent(false); 
    int qryNo1 = ++qryNo; 
    ThreadPool.QueueUserWorkItem(
     delegate 
      { 
       try 
       { 
        // Code to execute whatever thread's function is... 
       } 
       catch (SomeCustomException iX) 
       { 
        // catch code 
       }           } 
       finally { lock (locker) txEvnt.Set(); } 
      }); 
    waitHndls.Add(txEvnt); 
} 
util.WaitAll(waitHndls.ToArray()); 

Answer 7

好像WaitHandle.WaitAll应该解决这个问题。

您的主线程将需要保持对工作线程等待句柄的引用。当它需要同步时，将这些句柄传递给上述方法。工作线程在其代码中的适当位置线程发出信号。

如果工作线程循环或需要“脉冲”多次，你可以使用AutoResetEvents，像这样：

public void WorkerMethod() {   
    DoFirstThing(); 
    this.autoResetEvent.Set(); 
    DoSecondThing(); 
    this.autoResetEvent.Set(); 
    // etc. 
} 

如果没有（如果只需要在主线程知道工作者线程已经过去了一些门槛），ManualResetEvents会很好。

有几件事情需要提防使用了WaitAll时（从MSDN WaitAll文档）的：

在一些实施中，如果超过64 句柄传递，一个 NotSupportedException异常被抛出。如果 该阵列包含重复项，则 调用失败，并返回 DuplicateWaitObjectException。

但是，一个进程真的可以利用超过64个线程的优势很少，所以这个限制通常并不重要。

Answer 8

使用Thread.Join（即阻塞调用线程，直到某个线程终止，同时继续执行标准的COM和SendMessage消息泵）像实例方法：

using System; 
using System.Threading; 

class IsThreadPool 
{ 
    static void Main() 
    { 
     AutoResetEvent autoEvent = new AutoResetEvent(false); 

     Thread regularThread = 
      new Thread(new ThreadStart(ThreadMethod)); 
     regularThread.Start(); 
     ThreadPool.QueueUserWorkItem(new WaitCallback(WorkMethod), 
      autoEvent); 

     // __________ Wait for foreground thread to end. __________ 
     regularThread.Join(); 

     // Wait for background thread to end. 
     autoEvent.WaitOne(); 
    } 

    static void ThreadMethod() 
    { 
     Console.WriteLine("ThreadOne, executing ThreadMethod, " + 
      "is {0}from the thread pool.", 
      Thread.CurrentThread.IsThreadPoolThread ? "" : "not "); 
    } 

    static void WorkMethod(object stateInfo) 
    { 
     Console.WriteLine("ThreadTwo, executing WorkMethod, " + 
      "is {0}from the thread pool.", 
      Thread.CurrentThread.IsThreadPoolThread ? "" : "not "); 

     // Signal that this thread is finished. 
     ((AutoResetEvent)stateInfo).Set(); 
    } 
} 

Answer 9

尝试使用这样的：

int threadsCompleted = 0; 
int numberOfThreads = 4; 
ManualResetEvent completedEvent = new ManualResetEvent(false); 

在每个线程：

// Do task 

if (Interlocked.Increment(threadsCompleted) == numberOfThreads) 
    completedEvent.Set(); 

主线程：

completedEvent.WaitOne(); 

Answer 10

所有在互联网上的人尝试使用EventHandles和WaitAll()数组。我想出了以下的课程，这个课程在资源上要轻得多。我试图想到不同的比赛场景，我相信这段代码没有竞争条件。（在递减和检查Count上的条件之间存在理论上的竞争，但据我所知它不影响功能，并且代码将始终工作。）

要使用此类，需要同步的所有线程必须调用其方法Wait()。他们将阻止，直到Count线程数称为Wait()。一个实例只能用于同步一次（它不能被重置）。

internal class ThreadBarrier 
{ 
    private ManualResetEvent BarrierEvent; 
    private int Count; 

    internal ThreadBarrier(int count) 
    { 
     BarrierEvent = new ManualResetEvent(false); 
     Count = count; 
    } 

    internal void Wait() 
    { 
     Interlocked.Decrement(ref Count); 
     if (Count > 0) 
      BarrierEvent.WaitOne(); 
     else 
      BarrierEvent.Set(); 
    } 
}