C# 阻止集合+；每个阻塞集合有多个工作线程+；等待工作完成

我必须在1000条信息中批量执行操作，比如操作A、B、C。我可以并行执行这些操作。 我为他们创建了小组。为了增加并行性，我在每个组中创建了具有的子组。子组中具有的任务需要串行执行。但两个子组可以并行执行。 在一批1000次完成后，我必须做一些处理，即以db保存。但我无法理解，如何等待所有的任务完成（我不感兴趣的是在1000拍结束时在中间等待）。欢迎提出任何建议

public class OrderlyThreadPool<t> : IDisposable
{
    BlockingCollection<t> _workingqueue = null;
    Action<t> _handler = null;
    public OrderlyThreadPool(int wrkerCount, Action<t> handler)
    {
        _workingqueue = new BlockingCollection<t>();
        _handler = handler;
        Worker worker = new Worker(wrkerCount, Process); //WorkerCount is always 1
        worker.Start();
    }

    public void AddItem(t item)
    {
        _workingqueue.Add(item);
    }
    private void Process()
    {
        foreach (t item in _workingqueue.GetConsumingEnumerable())
        {
            _handler(item);
        }
    }
    public void Dispose()
    {
        _workingqueue.CompleteAdding();
        _workingqueue = null;
    }

}

public class Worker
{
    int _wrkerCount = 0;
    Action _action = null;
    public Worker(int workerCount, Action action)
    {
        _wrkerCount = workerCount;
        _action = action;

    }
    public void Start()
    {
        // Create and start a separate Task for each consumer:
        for (int i = 0; i < _wrkerCount; i++)
        {
            Task.Factory.StartNew(_action);
        }
    }
}

公共类OrderlyThreadPool:IDisposable { BlockingCollection\u workingqueue=null； 动作_handler=null； public OrderlyThreadPool（int wrkerCount，操作处理程序） { _workingqueue=新建BlockingCollection（）； _handler=handler； 工人工人=新工人（工人计数，进程）；//工人计数始终为1 worker.Start（）； } 公共无效附加项（t项） { _工作队列。添加（项）； } 私有无效进程（） { foreach（工作队列中的t项。GetConsumingEnumerable（）） { _经办人（项目）； } } 公共空间处置（） { _workingqueue.CompleteAdding（）； _workingqueue=null； } } 公社工人 { int _wrkerCount=0； Action _Action=null； 公共工作者（国际工人计数、行动） { _wrkerCount=工作计数； _行动=行动； } 公开作废开始（） { //为每个使用者创建并启动单独的任务： 对于（int i=0；i<\u wrkerCount；i++） { 任务.工厂.启动新（_操作）； } } } 因此，基本上我将为每个子组创建OrderlyThreadPool。 我接收来自say source的消息，如果没有可用消息，它将阻止接收。所以我的代码看起来像

while(true)
{

    var message = GetMsg();

    foreach(OrderlyThreadPool<Msg> a in myList)
    {
        a.AddMsg(message);

    }

    if(msgCount > 1000)
    {
    Wait for all threads to finish work;

    }
    else
    {
    msgCount =msgCount+1;

    }

}

while（true）
{
var message=GetMsg（）；
foreach（myList中的OrderlyThreadPool a）
{
a、 AddMsg（消息）；
}
如果（msgCount>1000）
{
等待所有线程完成工作；
}
其他的
{
msgCount=msgCount+1；
}
}

您开始执行任务，但不保留参考资料。只需存储这些任务，通过Worker和OrderlyThreadPool公开它们，然后使用

Task。当所有任务都要等待它们全部完成时：

public class Worker
{
    //...
    List<Task> _tasks = new List<Task>();
    public Task Completion { get { return Task.WhenAll(_tasks); } }
    public void Start()
    {
        // Create and start a separate Task for each consumer:
        for (int i = 0; i < _wrkerCount; i++)
        {
            Tasks.Add(Task.Factory.StartNew(_action));
        }
    }
}

public class OrderlyThreadPool<t> : IDisposable
{
    //...
    public Task Completion { get { return _worker.Completion; }}
}


但是，您应该考虑使用TPL数据流来代替。这是一个基于参与者的框架，封装了完成、批处理、并发级别等…
您好，我的情况是，假设我的列表中只有6个成员。因此，对于1个消息，将执行6个任务。我想知道什么时候所有的任务都执行了1000次。ie已处理1000条消息。所以我不知道我该怎么做，有什么建议吗
await Task.WhenAll(myList.Select(orderlyThreadPool => orderlyThreadPool.Completion));