生成多个线程进行工作，然后等到全部完成

Question

只是想要一些关于多线程任务的“最佳实践”的建议。

例如，我们有一个 C# 应用程序，它在启动时从数据库中的各种“类型”表中读取数据，并将信息存储在我们在应用程序周围传递的集合中。这可以防止我们在每次需要这些信息时访问数据库。

此时应用程序正在同步从 10 个表中读取数据。我真的很想让应用程序从不同线程中的每个表中读取，所有这些都并行运行。应用程序将等待所有线程完成，然后再继续启动应用程序。

我已经研究过 BackGroundWorker，但只是想要一些关于完成上述工作的建议。

1. 为了加快我们的应用程序的启动时间，该方法听起来合乎逻辑吗
2. 我们如何最好地处理所有线程，记住每个线程的工作是相互独立的，我们只需要等待所有线程完成后再继续。

我期待一些答案

Answer 1

我的偏好是通过单个 WaitHandle 来处理这个问题，并使用 Interlocked 来避免锁定在计数器上：

class Program
{
    static void Main(string[] args)
    {
        int numThreads = 10;
        ManualResetEvent resetEvent = new ManualResetEvent(false);
        int toProcess = numThreads;

        // Start workers.
        for (int i = 0; i < numThreads; i++)
        {
            new Thread(delegate()
            {
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
                // If we're the last thread, signal
                if (Interlocked.Decrement(ref toProcess) == 0)
                    resetEvent.Set();
            }).Start();
        }

        // Wait for workers.
        resetEvent.WaitOne();
        Console.WriteLine("Finished.");
    }
}

这很好用，并且可以扩展到任意数量的线程处理，而不会引入锁定。

Answer 2

我喜欢@Reed 的解决方案。在 .NET 4.0 中实现相同功能的另一种方法是使用 CountdownEvent。

class Program
{
    static void Main(string[] args)
    {
        var numThreads = 10;
        var countdownEvent = new CountdownEvent(numThreads);

        // Start workers.
        for (var i = 0; i < numThreads; i++)
        {
            new Thread(delegate()
            {
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
                // Signal the CountdownEvent.
                countdownEvent.Signal();
            }).Start();
        }

        // Wait for workers.
        countdownEvent.Wait();
        Console.WriteLine("Finished.");
    }
}

Answer 3

如果您有超过 64 个 STA 线程的等待句柄，如 Mark 所说。你可以用你的线程创建一个列表，然后等待所有线程在第二个循环中完成。

//check that all threads have completed.
foreach (Thread thread in threadList)
{
     thread.Join();

}  

Answer 4

如果您不在 .NET 4.0 上，那么您可以使用 ListManualResetEvent>，每个线程一个，Wait 则它们是 Set。要在多个线程上等待，您可以考虑使用WaitAll，但要注意 64 个等待句柄的限制。如果您需要的不止这些，您可以遍历它们并单独等待每个。

如果您想要更快的启动体验，您可能不需要在启动期间等待所有数据被读取。只需显示 GUI，任何丢失的信息都可以用某种“正在更新...”图标或类似图标显示为灰色。当信息进入时，只需触发一个事件来更新 GUI。甚至在读入所有表中的所有数据之前，用户就可以开始执行许多操作。

Answer 5

如果您喜欢冒险，可以使用 C# 4.0 和任务并行库：

Parallel.ForEach(jobList, curJob => {
  curJob.Process()
});

Answer 6

这是等待多个并行操作的两种模式。诀窍是您必须将主线程也视为并行操作之一。否则，工作线程中的完成信号与主线程等待该信号之间存在微妙的竞争条件。

int threadCount = 1;
ManualResetEvent finished = new ManualResetEvent(false);
for (int i = 0; i < NUM_WORK_ITEMS; i++)
{
  Interlocked.Increment(ref threadCount); 
  ThreadPool.QueueUserWorkItem(delegate 
  { 
      try 
      { 
           // do work 
      } 
      finally 
      { 
          if (Interlocked.Decrement(ref threadCount) == 0) finished.Set();
      } 
  }); 
}
if (Interlocked.Decrement(ref threadCount) == 0) finished.Set();
finished.WaitOne(); 

作为个人喜好，我喜欢使用 CountdownEvent 类为我进行计数，这在 .NET 4.0 中可用。

var finished = new CountdownEvent(1);
for (int i = 0; i < NUM_WORK_ITEMS; i++)
{
  finished.AddCount();
  ThreadPool.QueueUserWorkItem(delegate 
  { 
      try 
      { 
           // do work 
      } 
      finally 
      { 
        finished.Signal();
      } 
  }); 
}
finished.Signal();
finished.Wait(); 

上面的示例使用ThreadPool，但您可以将其替换为您喜欢的任何线程机制。

Answer 7

只是为了好玩，@Reed 用 Monitor 做了什么。 :P

class Program
{
    static void Main(string[] args)
    {
        int numThreads = 10;
        int toProcess = numThreads;
        object syncRoot = new object();

        // Start workers.
        for (int i = 0; i < numThreads; i++)
        {
            new Thread(delegate()
            {
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
                // If we're the last thread, signal
                if (Interlocked.Decrement(ref toProcess) == 0)
                {
                    lock (syncRoot)
                    {
                        Monitor.Pulse(syncRoot);
                    }
                }
            }).Start();
        }

        // Wait for workers.
        lock (syncRoot)
        {
            if (toProcess > 0)
            {
                Monitor.Wait(syncRoot);
            }
        }

        Console.WriteLine("Finished.");
    }
}

Answer 8

TPL 的另一种可能性，假设 jobs 是要处理的项目集合或要运行的子线程：

Task.WaitAll(jobs
    .Select(job => TaskFactory.StartNew(() => /*run job*/))
    .ToArray());

Answer 9

假设数据库读取器线程一完成就返回，您可以简单地从启动线程依次在所有十个线程上调用 Thread.Join。

Answer 10

如果您使用的是 .NET 3.5 或更低版本，则可以使用 AsyncResult 或 BackgroundWorker 数组并计算返回的线程数（只是不要忘记使用联锁操作减少计数器）（请参阅 http://www.albahari.com/threading/ 作为参考)。

如果您使用的是 .NET 4.0，并行 for 是最简单的方法。

Answer 11

我喜欢使用的更简单的方法：

    private int ThreadsCount = 100; //initialize threads count
    private void button1_Click(object sender, EventArgs e)
    {   
        for (int i = 0; i < ThreadsCount; i++)
        {
            Thread t = new Thread(new ThreadStart(myMethod));
            t.IsBackground = true;
            t.Start(); 
        } 
    }

    private void myMethod()
    {
        //everytime a thread finishes executing decrease the threads count
        ThreadsCount = ThreadsCount - 1;

        if (ThreadsCount < 1)
        {
            //if all threads finished executing do whatever you wanna do here..
            MessageBox.Show("Finished Executing all threads!!!");
        }
    }

Answer 12

发帖可能是为了帮助其他人，花了很多时间寻找像我想出的解决方案。所以我采取了一些不同的方法。当线程启动和停止时，我正在关闭许多线程并增加一个计数器并减少一个计数器。然后在 main 方法中，我想暂停并等待线程完成。

while (threadCounter > 0)
{
    Thread.Sleep(500); //Make it pause for half second so that we don’t spin the cpu out of control.
}

记录在我的博客上。 http://www.adamthings.com/post/2012/07/11/ensure-threads-have-finished-before-method-continues-in-c/