C#:等待所有线程完成

我正在编写我正在编写的代码中的常见模式,我需要等待组中的所有线程完成,并且超时.超时应该是所有线程完成所需的时间,因此简单地为每个线程执行thread.Join(timeout)将不起作用,因为可能的超时是超时*numThreads.

现在我做类似以下的事情:

var threadFinishEvents = new List();

foreach (DataObject data in dataList)
{
    // Create local variables for the thread delegate
    var threadFinish = new EventWaitHandle(false, EventResetMode.ManualReset);
    threadFinishEvents.Add(threadFinish);

    var localData = (DataObject) data.Clone();
    var thread = new Thread(
        delegate()
        {
            DoThreadStuff(localData);
            threadFinish.Set();
        }
    );
    thread.Start();
}

Mutex.WaitAll(threadFinishEvents.ToArray(), timeout);

但是,对于这种事情,似乎应该有一个更简单的习语.

1> Martin v. Lö..：

---

我仍然认为使用Join更简单.记录预期的完成时间(如现在+超时),然后在循环中执行

if(!thread.Join(End-now))
    throw new NotFinishedInTime();

2> T. Webster..：

---

使用.NET 4.0,我发现System.Threading.Tasks更容易使用.这是旋转等待循环,对我来说可靠.它会阻塞主线程,直到完成所有任务.还有Task.WaitAll,但这对我来说并不总是有用.

        for (int i = 0; i < N; i++)
        {
            tasks[i] = Task.Factory.StartNew(() =>
            {               
                 DoThreadStuff(localData);
            });
        }
        while (tasks.Any(t => !t.IsCompleted)) { } //spin wait

---

你想要`Task.WaitAll(tasks)`而不是那个旋转.

---

@ T.Webster - 你说'Task.WaitAll`并不总能为你工作是什么意思？你是否建议这种方法有bug？你能提供一些例子吗？它总是适合我.另一方面,你建议的旋转是非常昂贵的事情.你正在锤击你的CPU.`Task.WaitAll`是更好的解决方案.

---

抱歉,-1表示spinwait.动机"Task.WaitAll并不总是对我有用"没有更多的细节并不是这样做的有效借口.

---

如果你使用这个选项,我建议至少把'Thread.Yield()`放在while体中.

3> Brian Gideon..：

---

由于问题得到了解决,我将继续发布我的解决方案.

using (var finished = new CountdownEvent(1)) 
{ 
  for (DataObject data in dataList) 
  {   
    finished.AddCount();
    var localData = (DataObject)data.Clone(); 
    var thread = new Thread( 
        delegate() 
        {
          try
          {
            DoThreadStuff(localData); 
            threadFinish.Set();
          }
          finally
          {
            finished.Signal();
          }
        } 
    ); 
    thread.Start(); 
  }  
  finished.Signal(); 
  finished.Wait(YOUR_TIMEOUT); 
} 

4> Omer van Klo..：

---

在我的脑海中,你为什么不只是Thread.Join(超时)并从总超时中删除加入所花费的时间？

// pseudo-c#:

TimeSpan timeout = timeoutPerThread * threads.Count();

foreach (Thread thread in threads)
{
    DateTime start = DateTime.Now;

    if (!thread.Join(timeout))
        throw new TimeoutException();

    timeout -= (DateTime.Now - start);
}

编辑:现在代码更少伪.不明白为什么你会修改答案-2当你修改的答案+4完全相同,只是不那么详细.

---

首先,这是伪代码,因为它不是真正的代码,所以是不完整的.我假设等于或小于零的时间会抛出什么东西.其次,如果第一个线程消耗整个时间,则操作应该作为一个整体超时.根据问题,这是正确的.

5> Vincent..：

---

这不回答问题(没有超时),但我做了一个非常简单的扩展方法来等待集合的所有线程:

using System.Collections.Generic;
using System.Threading;
namespace Extensions
{
    public static class ThreadExtension
    {
        public static void WaitAll(this IEnumerable threads)
        {
            if(threads!=null)
            {
                foreach(Thread thread in threads)
                { thread.Join(); }
            }
        }
    }
}

然后你只需致电:

List threads=new List();
//Add your threads to this collection
threads.WaitAll();

6> Jon Norton..：

---

这可能不是您的选择,但如果您可以使用.NET的并行扩展,那么您可以使用Tasks代替原始线程,然后使用Task.WaitAll()等待它们完成.