并行任务和子任务工作流程

Question

我是 C# 线程和任务的新手，我正在尝试开发一个工作流但没有成功，可能是因为我将任务与迭代混合...

重点是：

我有一堆列表，在每个列表中都有一些事情要做，并且需要使它们尽可能多地并行工作并且尽可能减少阻塞，并且一旦每个 subBunchOfThingsTodo 完成（这意味着每一件事在里面做是并行完成的）它做了一些事情（DoSomethingAfterEveryThingToDoOfThisSubBunchOfThingsAreDone()）。

例如：

bunchOfSubBunchsOfThingsTodo

• subBunchOfThingsTodo

  • ThingToDo1
  • ThingToDo2

• subBunchOfThingsTodo

  • ThingToDo1
  • ThingToDo2
  • ThingToDo3

• subBunchOfThingsTodo

  • ThingToDo1
  • ThingToDo2...

这就是我正在尝试的方式，但不幸的是，每次迭代都会等待前一个 bundleOfThingsToDo，我需要它们并行工作。 要做的事情也是如此，他们等待上一件事情开始......

List<X> bunchOfSubBunchsOfThingsTodo = getBunchOfSubBunchsOfThingsTodo();     
foreach (var subBunchOfThingsToDo in bunchOfSubBunchsOfThingsTodo)
{
    int idSubBunchOfThingsToDo = subBunchOfThingsToDo.ThingsToDo.FirstOrDefault().IdSubBunchOfThingsToDo;
    
    var parent = Task.Factory.StartNew(() =>
    {
        foreach (var thingToDo in subBunchOfThingsToDo.ThingsToDo)
        {
            var child = Task.Factory.StartNew(() =>
            {
               //Do some stuff with thingToDo... Here I call several business methods
            });
        }
    });

    parent.Wait();
    DoSomethingAfterEveryThingToDoOfThisSubBunchOfThingsAreDone(idSubBunchOfThingsToDo);
}

Answer 1

您可能想尝试使用 Task.WhenAll 并使用 linq 来生成热任务集合：

static async void ProcessThingsToDo(IEnumerable<ThingToDo> bunchOfThingsToDo)
{
    IEnumerable<Task> GetSubTasks(ThingToDo thing) 
        => thing.SubBunchOfThingsToDo.Select( async subThing => await Task.Run(subThing));

    var tasks = bunchOfThingsToDo
        .Select(async thing => await Task.WhenAll(GetSubTasks(thing)));

    await Task.WhenAll(tasks);
}

这样，您将在单独的任务上运行每个 subThingToDo，并且您只会获得一个由每个 thingToDo

的所有子任务组成的任务

编辑

ThingToDo 在这个示例中是一个相当简单的类：

class ThingToDo
{
    public IEnumerable<Action> SubBunchOfThingsToDo { get; }
}

Answer 2

只需对您的代码进行最少的更改，您就可以尝试这种方式：

    var toWait = new List<Task>();
    List<X> bunchOfSubBunchsOfThingsTodo = getBunchOfSubBunchsOfThingsTodo();     

    foreach (var subBunchOfThingsToDo in bunchOfSubBunchsOfThingsTodo)
    {
        int idSubBunchOfThingsToDo = subBunchOfThingsToDo.ThingsToDo.FirstOrDefault().IdSubBunchOfThingsToDo;
    
        var parent = Task.Factory.StartNew(() =>
        {
            Parallel.ForEach(subBunchOfThingsToDo.ThingsToDo,
                thingToDo =>
                {
                        //Do some stuff with thingToDo... Here I call several business methods
                });
        });
    
        //parent.Wait();
        var handle = parent.ContinueWith((x) =>
        {
            DoSomethingAfterEveryThingToDoOfThisSubBunchOfThingsAreDone(idSubBunchOfThingsToDo);
        })
        .Start();

        toWait.Add(handle);
    }

    Task.WhenAll(toWait);
        

感谢 downvoters 团队，他们提出了“好的”解决方案：

    var bunchOfSubBunchsOfThingsTodo = getBunchOfSubBunchsOfThingsTodo();
    var toWait = bunchOfSubBunchsOfThingsTodo
        .Select(subBunchOfThingsToDo =>
        {
            return Task.Run(() =>
            {
                int idSubBunchOfThingsToDo = subBunchOfThingsToDo.ThingsToDo.FirstOrDefault().IdSubBunchOfThingsToDo;

                Parallel.ForEach(subBunchOfThingsToDo.ThingsToDo,
                    thingToDo =>
                    {
                        //Do some stuff with thingToDo... Here I call several business methods
                    });

                DoSomethingAfterEveryThingToDoOfThisSubBunchOfThingsAreDone(idSubBunchOfThingsToDo);
            });
        });

    Task.WhenAll(toWait);