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

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.
  }
}