如何确保一个线程恰好在特定数量的其他线程运行结束后运行？

Question

我在 C# 中有一个这样的类：

public MyClass
{
   public void Start() { ... }

   public void Method_01() { ... }
   public void Method_02() { ... }
   public void Method_03() { ... }
}

当我调用“Start()”方法时，外部类开始工作，并将创建许多并行线程，这些并行线程调用“Method_01()”和“Method_02()”形式以上类。外部类工作结束后，“Method_03()”将在另一个并行线程中运行。

“Method_01()”或“Method_02()”线程在创建 Method_03() 线程之前创建，但不保证在“Method_03()”线程启动之前结束。我的意思是“Method_01()”或“Method_02()”将失去其CPU 轮次，而“Method_03”将获得CPU 轮次并将完全结束。

在“Start()”方法中，我知道应该创建和运行“Method_01”和“Method_02()”的线程总数。问题是我正在寻找一种使用信号量或互斥体的方法，以确保“Method_03()”的第一个语句将在运行“Method_01()”或“Method_02()”的所有线程结束后运行。

Answer 1

我想到的三个选项是：

• 保留一个 Thread 实例数组，并从 Method_03 对所有实例调用 Join。
• 使用单个 CountdownEvent 实例并从 Method_03 调用 Wait。
• 为每个 Method_01 或 Method_02 调用分配一个 ManualResetEvent，并对来自 的所有调用调用 WaitHandle.WaitAll Method_03（这不太可扩展）。

我更喜欢使用 CountdownEvent ，因为它的用途更加广泛，并且仍然具有超强的可扩展性。

public class MyClass
{
  private CountdownEvent m_Finished = new CountdownEvent(0);

  public void Start()
  {
    m_Finished.AddCount(); // Increment to indicate that this thread is active.

    for (int i = 0; i < NUMBER_OF_THREADS; i++)
    {
      m_Finished.AddCount(); // Increment to indicate another active thread.
      new Thread(Method_01).Start();
    }

    for (int i = 0; i < NUMBER_OF_THREADS; i++)
    {
      m_Finished.AddCount(); // Increment to indicate another active thread.
      new Thread(Method_02).Start();
    }

    new Thread(Method_03).Start();

    m_Finished.Signal(); // Signal to indicate that this thread is done.
  }

  private void Method_01()
  {
    try
    {
      // Add your logic here.
    }
    finally
    {
      m_Finished.Signal(); // Signal to indicate that this thread is done.
    }
  }

  private void Method_02()
  {
    try
    {
      // Add your logic here.
    }
    finally
    {
      m_Finished.Signal(); // Signal to indicate that this thread is done.
    }
  }

  private void Method_03()
  {
    m_Finished.Wait(); // Wait for all signals.
    // Add your logic here.
  }
}

Answer 2

这对于 Tasks 来说似乎是一项完美的工作。下面我假设允许 Method01 和 Method02 并发运行，没有特定的调用或完成顺序（没有保证，只是在没有测试的情况下输入内存不足）：

int cTaskNumber01 = 3, cTaskNumber02 = 5;
Task tMaster = new Task(() => {
    for (int tI = 0; tI < cTaskNumber01; ++tI)
        new Task(Method01, TaskCreationOptions.AttachedToParent).Start();
    for (int tI = 0; tI < cTaskNumber02; ++tI)
        new Task(Method02, TaskCreationOptions.AttachedToParent).Start();
});
// after master and its children are finished, Method03 is invoked
tMaster.ContinueWith(Method03);
// let it go...
tMaster.Start();

Answer 3

听起来您需要做的是为 Method_01 和 Method_02 创建一个 ManualResetEvent （初始化为取消设置）或其他一些 WatHandle，然后让 Method_03 的线程使用 WaitHandle.WaitAll 上的集合手柄。

或者，如果您可以引用用于运行 Method_01 和 Method_02 的线程变量，则可以让 Method_03 的线程使用 Thread.Join 来等待这两个线程。然而，这假设这些线程在完成 Method_01 和 Method_02 的执行时实际上已终止 - 如果它们没有完成，则需要诉诸我提到的第一个解决方案。

Answer 4

为什么不使用静态变量static volatile int threadRuns，它用将运行的线程数Method_01和Method_02进行初始化。
然后，您修改这两个方法中的每一个，以在退出之前递减 threadRuns：

...
lock(typeof(MyClass)) {
    --threadRuns;
}
...

然后在 Method_03 的开头，您等到 threadRuns 为 0，然后继续：

while(threadRuns != 0)
   Thread.Sleep(10);

我是否正确理解了问题？

Answer 5

事实上，Barrier 类中有一个替代方案，它是 .Net 4.0 中新增的。这简化了跨多个线程发送信号的方式。

您可以执行类似以下代码的操作，但这在同步不同处理线程时最有用。

 public class Synchro
    {
        private Barrier _barrier;          

        public void Start(int numThreads)
        {
            _barrier = new Barrier((numThreads * 2)+1);
            for (int i = 0; i < numThreads; i++)
            {
                new Thread(Method1).Start();
                new Thread(Method2).Start(); 
            }
            new Thread(Method3).Start();
        }

        public void Method1()
        {
            //Do some work
            _barrier.SignalAndWait();
        }

        public void Method2()
        {
            //Do some other work.
            _barrier.SignalAndWait();
        }

        public void Method3()
        {
            _barrier.SignalAndWait();               
            //Do some other cleanup work.
        }
    }

我还想建议，由于您的问题陈述非常抽象，因此通常使用 countdownevent 解决的实际问题现在可以使用新的 Parallel 或 PLINQ 功能更好地解决。如果您实际上在代码中处理集合或某些内容，则可能会出现如下所示的内容。

 public class Synchro
    {
        public void Start(List<someClass> collection)
        {
            new Thread(()=>Method3(collection));
        }

        public void Method1(someClass)
        {
            //Do some work.               
        }

        public void Method2(someClass)
        {
            //Do some other work.                
        }

        public void Method3(List<someClass> collection)
        {
            //Do your work on each item in Parrallel threads.
            Parallel.ForEach(collection, x => { Method1(x); Method2(x); });
            //Do some work on the total collection like sorting or whatever.                
        }
    }