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

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，然后从Method_03 对所有它们调用WaitHandle.WaitAll（这不是很可扩展）。

我更喜欢使用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 的 Thread 变量，您可以让 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.                
        }
    }