c# - 依赖任务图 : neat parallel execution in . 网络？

Question

在 .Net 中是否有一种优雅的方式来在多线程中执行命令图，其中每个命令只能在其所有父命令都已执行后才能执行？

例如，Visual Studio 在多线程编译解决方案时进行这种计算(每个项目都可以在编译所有依赖项后进行编译)。

另一个例子可能是如果你想克隆(或加载)一个完整的数据库，一个表一个表而不破坏关系约束，从顶级父表开始，然后做子表。 (假设它至少存在一种拓扑排序的表)。

System.Threading.Tasks.Task 似乎可以使用“task.ContinueWith()”处理命令链的情况，但它似乎不会威胁到命令图的情况。

尝试在任务流程开始时将任务与“Task.WaitAll(dependencies)”一起使用。但它效率不高，因为它开始启动第一个任务(可能等待)而不是启动准备就绪的任务。这是我用来检查它的代码:

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Threading;

namespace ParallelProcessing
{
    /// <summary>
    /// There is the exemple Dependency graph:
    /// 
    /// MyTypedDataSet (long job)         MyTools                   
    ///  ^                   ^             ^   ^                       
    ///  |- Project 0        |             |   |- MyControls           
    ///  ...                 |             |                 
    ///  |- Project 99       |- MyForm ----|
    ///           
    /// 
    /// 'MyControls' should compile quickly after MyTools. Instead of that, MyControls is flooded by Project 0..99
    /// </summary>
    public class TestTasks
    {
        public static void Trace(string message)
        {
            Console.WriteLine("[" + Task.CurrentId + "] " + message);
            System.Diagnostics.Trace.WriteLine(DateTime.Now.ToString("mm:ss.fff") + " [" + Task.CurrentId + "] " + message);
        }
        private static void compile(string projectName, int duration, params Task[] dependency)
        {
            Task.WaitAll(dependency);
            TestTasks.Trace("Start compiling " + projectName);
            Thread.Sleep(duration);
            TestTasks.Trace("End compiling " + projectName);
        }

        public static void RunTest()
        {
            Task taskMyTypedDataSet = new Task(() => TestTasks.compile("MyTypedDataSet", 10000));
            taskMyTypedDataSet.Start();

            Task taskMyTools = new Task(() => TestTasks.compile("MyTools", 2000));
            taskMyTools.Start();

            List<Task> lotOfOtherProjets = new List<Task>();
            for (int i = 0; i < 100; i++)
            {
                string projectName = "Project" + i;
                Task task = new Task(() => TestTasks.compile(projectName, 100, taskMyTypedDataSet));
                task.Start();
                lotOfOtherProjets.Add(task);
            }
            Task taskMyControls = new Task(() => TestTasks.compile("MyControls", 100, taskMyTools));
            taskMyControls.Start();

            Task taskMyForms = new Task(() => TestTasks.compile("MyForms", 100, taskMyControls, taskMyTypedDataSet));
            taskMyForms.Start();

            Task.WaitAll(taskMyTypedDataSet, taskMyForms);
            Task.WaitAll(lotOfOtherProjets.ToArray());
            TestTasks.Trace("Process done");

            Console.ReadLine();
        }

    }
}

你知道有没有解决这类问题的好方法？

Answer 1

您可以使用 TaskFactory.ContinueWhenAll()为此。

例如:

var task1 = Task.Factory.StartNew(() => { /* some computation */ });
var task2 = Task.Factory.StartNew(() => { /* another computation */ });
var continuationTask = Task.Factory.ContinueWhenAll(
    new[] { task1, task2 }, tasks => { /* dependent computation */ });

在 .Net 4.5 中，Task.WhenAll()做一些非常相似的事情。