为什么平行。Foreach创建无尽的线程？

Question

下面的代码继续创建线程，即使队列是空的...直到最终发生OutOfMemory异常。如果我用一个常规的foreach替换并行。Foreach，这不会发生。有人知道为什么会发生这种情况吗？

public delegate void DataChangedDelegate(DataItem obj);

public class Consumer
{
    public DataChangedDelegate OnCustomerChanged;
    public DataChangedDelegate OnOrdersChanged;

    private CancellationTokenSource cts;
    private CancellationToken ct;
    private BlockingCollection<DataItem> queue;

    public Consumer(BlockingCollection<DataItem> queue) {
        this.queue = queue;
        Start();
    }

    private void Start() {
        cts = new CancellationTokenSource();
        ct = cts.Token;
        Task.Factory.StartNew(() => DoWork(), ct);
    }

    private void DoWork() {

        Parallel.ForEach(queue.GetConsumingPartitioner(), item => {
            if (item.DataType == DataTypes.Customer) {
                OnCustomerChanged(item);
            } else if(item.DataType == DataTypes.Order) {
                OnOrdersChanged(item);
            }
        });
    }
}

Answer 1

在任务并行库内部，并行。For和Parallel。Foreach遵循爬山算法来确定操作应使用多少并行性。

或多或少，他们从一个任务开始运行身体，移动到两个，等等，直到达到一个断点，他们需要减少任务数量。

这对于快速完成的方法体非常有效，但如果方法体需要很长时间才能运行，则可能需要很长时间才能意识到需要减少并行量。在此之前，它会继续添加任务，并可能导致计算机崩溃。

我在任务并行库的一位开发人员的演讲中学习了上述内容。

指定MaxDegreeOfParallelism可能是最简单的方法。

Answer 2

生产者/消费者模式主要用于只有一个生产者和一个消费者的情况。

但是，您试图实现的（多个消费者）更适合Worklist模式。以下代码摘自unit2幻灯片“2c-共享内存模式”的幻灯片，来自犹他大学教授的并行编程课程，可在http://ppcp.codeplex.com/下载

BlockingCollection<Item> workList;
CancellationTokenSource cts;
int itemcount

public void Run()
{
  int num_workers = 4;

  //create worklist, filled with initial work
  worklist = new BlockingCollection<Item>(
    new ConcurrentQueue<Item>(GetInitialWork()));

  cts = new CancellationTokenSource();
  itemcount = worklist.Count();

  for( int i = 0; i < num_workers; i++)
    Task.Factory.StartNew( RunWorker );
}

IEnumberable<Item> GetInitialWork() { ... }

public void RunWorker() {
  try  {
    do {
      Item i = worklist.Take( cts.Token );
      //blocks until item available or cancelled
          Process(i);
      //exit loop if no more items left
    } while (Interlocked.Decrement( ref itemcount) > 0);
  } finally {
      if( ! cts.IsCancellationRequested )
        cts.Cancel();
    }
  }
}

public void AddWork( Item item) {
  Interlocked.Increment( ref itemcount );
  worklist.Add(item);
}

public void Process( Item i ) 
{
  //Do what you want to the work item here.
}

前面的代码允许您将工作列表项添加到队列中，并允许您设置任意数量的worker（在本例中为四个）以将项目从队列中拉出并处理它们。

关于.Net 4.0上的并行性的另一个重要资源是《使用Microsoft.Net进行并行编程》一书，该书可在以下网站免费获得：http://msdn.microsoft.com/en-us/library/ff963553

Answer 3

我认为并行。Foreach（）主要是为了处理有界集合而制作的。它不期望像Get消耗分区器（）返回的集合那样，其中MoveNext（）长时间阻塞。

问题是并行。ForEach（）试图找到最佳并行度，因此它启动的任务数量与任务调度程序运行的数量相同。但是任务调度器（TaskScheduler）发现有许多任务需要很长时间才能完成，而且它们什么都没有做（它们会阻塞），因此它会继续启动新的任务。

我认为最好的解决方案是设置MaxDegreeOfParallelism。

作为替代方案，您可以使用TPL数据流的ActionBlock。这种情况下的主要区别是，当没有要处理的项目时，ActionBlock不会阻止任何线程，因此线程的数量不会接近极限。