C#基于任务的异步编程

ゞ浴缸里的玫瑰 2023-10-01 20:14 12阅读 0赞

任务并行库 (TPL) 以“任务”的概念为基础，后者表示异步操作。 在某些方面，任务类似于线程或 [ThreadPool][] 工作项，但是抽象级别更高。 术语“任务并行”是指一个或多个独立的任务同时运行。 任务提供两个主要好处：

*  系统资源的使用效率更高，可伸缩性更好。
    
    在后台，任务排队到已使用算法增强的 [ThreadPool][]，这些算法能够确定线程数并随之调整，提供负载平衡以实现吞吐量最大化。 这会使任务相对轻量，你可以创建很多任务以启用细化并行。
 *  对于线程或工作项，可以使用更多的编程控件。
    
    任务和围绕它们生成的框架提供了一组丰富的 API，这些 API 支持等待、取消、继续、可靠的异常处理、详细状态、自定义计划等功能。

出于这两个原因，在 .NET 中，TPL 是用于编写多线程、异步和并行代码的首选 API。

### 隐式创建和运行任务 ###

[Parallel.Invoke][] 方法提供了一种简便方式，可同时运行任意数量的任意语句。 只需为每个工作项传入 [Action][] 委托即可。 创建这些委托的最简单方式是使用 lambda 表达式。 lambda 表达式可调用指定的方法，或提供内联代码。 下面的示例演示一个基本的 [Invoke][Parallel.Invoke] 调用，该调用创建并启动同时运行的两个任务。 第一个任务由调用名为 `DoSomeWork` 的方法的 lambda 表达式表示，第二个任务由调用名为 `DoSomeOtherWork` 的方法的 lambda 表达式表示。

备注

本文档使用 lambda 表达式在 TPL 中定义委托。 如果不熟悉 C\# 或 Visual Basic 中的 lambda 表达式，请参阅 [PLINQ 和 TPL 中的 Lambda 表达式][PLINQ _ TPL _ Lambda]。

C\#复制

Parallel.Invoke(() => DoSomeWork(), () => DoSomeOtherWork());

备注

[Task][] 在后台创建的 [Invoke][Parallel.Invoke] 实例数不一定与所提供的委托数相等。 TPL 可能会使用各种优化，特别是对于大量的委托。

有关详细信息，请参阅[如何：使用 Parallel.Invoke 来执行并行操作][Parallel.Invoke 1]。

为了更好地控制任务执行或从任务返回值，必须更加显式地使用 [Task][] 对象。

### 显式创建和运行任务 ###

不返回值的任务由 [System.Threading.Tasks.Task][Task] 类表示。 返回值的任务由 [System.Threading.Tasks.Task<TResult>][System.Threading.Tasks.Task_TResult] 类表示，该类从 [Task][] 继承。 任务对象处理基础结构详细信息，并提供可在任务的整个生存期内从调用线程访问的方法和属性。 例如，可以随时访问任务的 [Status][] 属性，以确定它是已开始运行、已完成运行、已取消还是引发了异常。 状态由 [TaskStatus][] 枚举表示。

在创建任务时，你赋予它一个用户委托，该委托封装该任务将执行的代码。 该委托可以表示为命名的委托、匿名方法或 lambda 表达式。 lambda 表达式可以包含对命名方法的调用，如下面的示例所示。 请注意，该示例包含对 [Task.Wait][] 方法的调用，以确保任务在控制台模式应用程序结束之前完成执行。

C\#复制

using System;
    using System.Threading;
    using System.Threading.Tasks;
    
    public class Example
    {
       public static void Main()
       {
          Thread.CurrentThread.Name = "Main";
    
          // Create a task and supply a user delegate by using a lambda expression.
          Task taskA = new Task( () => Console.WriteLine("Hello from taskA."));
          // Start the task.
          taskA.Start();
    
          // Output a message from the calling thread.
          Console.WriteLine("Hello from thread '{0}'.",
                            Thread.CurrentThread.Name);
          taskA.Wait();
       }
    }
    // The example displays output like the following:
    //       Hello from thread 'Main'.
    //       Hello from taskA.

你还可以使用 [Task.Run][] 方法通过一个操作创建并启动任务。 无论是哪个任务计划程序与当前线程关联，[Run][Task.Run] 方法都将使用默认的任务计划程序来管理任务。 不需要对任务的创建和计划进行更多控制时，首选 [Run][Task.Run] 方法创建并启动任务。

C\#复制

using System;
    using System.Threading;
    using System.Threading.Tasks;
    
    public class Example
    {
       public static void Main()
       {
          Thread.CurrentThread.Name = "Main";
    
          // Define and run the task.
          Task taskA = Task.Run( () => Console.WriteLine("Hello from taskA."));
    
          // Output a message from the calling thread.
          Console.WriteLine("Hello from thread '{0}'.",
                              Thread.CurrentThread.Name);
          taskA.Wait();
       }
    }
    // The example displays output like the following:
    //       Hello from thread 'Main'.
    //       Hello from taskA.

你还可以使用 [TaskFactory.StartNew][] 方法在一个操作中创建并启动任务。 不必将创建和计划分开并且需要其他任务创建选项或使用特定计划程序时，或者需要将其他状态传递到可以通过 [Task.AsyncState][] 属性检索到的任务时，请使用此方法，如下例所示。

C\#复制

using System;
    using System.Threading;
    using System.Threading.Tasks;
    
    class CustomData
    {
       public long CreationTime;
       public int Name;
       public int ThreadNum;
    }
    
    public class Example
    {
       public static void Main()
       {
          Task[] taskArray = new Task[10];
          for (int i = 0; i < taskArray.Length; i++) {
             taskArray[i] = Task.Factory.StartNew( (Object obj ) => {
                                                      CustomData data = obj as CustomData;
                                                      if (data == null)
                                                         return;
    
                                                      data.ThreadNum = Thread.CurrentThread.ManagedThreadId;
                                                   },
                                                   new CustomData() {Name = i, CreationTime = DateTime.Now.Ticks} );
          }
          Task.WaitAll(taskArray);
          foreach (var task in taskArray) {
             var data = task.AsyncState as CustomData;
             if (data != null)
                Console.WriteLine("Task #{0} created at {1}, ran on thread #{2}.",
                                  data.Name, data.CreationTime, data.ThreadNum);
          }
       }
    }
    // The example displays output like the following:
    //       Task #0 created at 635116412924597583 on thread #3.
    //       Task #1 created at 635116412924607584 on thread #4.
    //       Task #3 created at 635116412924607584 on thread #4.
    //       Task #4 created at 635116412924607584 on thread #4.
    //       Task #2 created at 635116412924607584 on thread #3.
    //       Task #6 created at 635116412924607584 on thread #3.
    //       Task #5 created at 635116412924607584 on thread #4.
    //       Task #8 created at 635116412924607584 on thread #4.
    //       Task #7 created at 635116412924607584 on thread #3.
    //       Task #9 created at 635116412924607584 on thread #4.

[Task][] 和 [Task<TResult>][System.Threading.Tasks.Task_TResult] 均公开静态 [Factory][] 属性，该属性返回 [TaskFactory][] 的默认实例，因此你可以调用该方法为 `Task.Factory.StartNew()`。 此外，在以下示例中，由于任务的类型为 [System.Threading.Tasks.Task<TResult>][System.Threading.Tasks.Task_TResult]，因此每个任务都具有包含计算结果的公共 [Task<TResult>.Result][Task_TResult_.Result] 属性。 任务以异步方式运行，可以按任意顺序完成。 如果在计算完成之前访问 [Result][Task_TResult_.Result] 属性，则该属性将阻止调用线程，直到值可用为止。

C\#复制

using System;
    using System.Threading.Tasks;
    
    public class Example
    {
       public static void Main()
       {
            Task<Double>[] taskArray = { Task<Double>.Factory.StartNew(() => DoComputation(1.0)),
                                         Task<Double>.Factory.StartNew(() => DoComputation(100.0)),
                                         Task<Double>.Factory.StartNew(() => DoComputation(1000.0)) };
    
            var results = new Double[taskArray.Length];
            Double sum = 0;
    
            for (int i = 0; i < taskArray.Length; i++) {
                results[i] = taskArray[i].Result;
                Console.Write("{0:N1} {1}", results[i],
                                  i == taskArray.Length - 1 ? "= " : "+ ");
                sum += results[i];
            }
            Console.WriteLine("{0:N1}", sum);
       }
    
       private static Double DoComputation(Double start)
       {
          Double sum = 0;
          for (var value = start; value <= start + 10; value += .1)
             sum += value;
    
          return sum;
       }
    }
    // The example displays the following output:
    //        606.0 + 10,605.0 + 100,495.0 = 111,706.0

有关详细信息，请参阅[如何：从任务中返回值][Link 1]。

使用 lambda 表达式创建委托时，你有权访问源代码中当时可见的所有变量。 然而，在某些情况下，特别是在循环中，lambda 不按照预期的方式捕获变量。 它仅捕获最终值，而不是它每次迭代后更改的值。 以下示例演示了该问题。 它将循环计数器传递给实例化 `CustomData` 对象并使用循环计数器作为对象标识符的 lambda 表达式。 如示例输出所示，每个 `CustomData` 对象都具有相同的标识符。

C\#复制

using System;
    using System.Threading;
    using System.Threading.Tasks;
    
    class CustomData
    {
       public long CreationTime;
       public int Name;
       public int ThreadNum;
    }
    
    public class Example
    {
       public static void Main()
       {
          // Create the task object by using an Action(Of Object) to pass in the loop
          // counter. This produces an unexpected result.
          Task[] taskArray = new Task[10];
          for (int i = 0; i < taskArray.Length; i++) {
             taskArray[i] = Task.Factory.StartNew( (Object obj) => {
                                                     var data = new CustomData() {Name = i, CreationTime = DateTime.Now.Ticks};
                                                     data.ThreadNum = Thread.CurrentThread.ManagedThreadId;
                                                     Console.WriteLine("Task #{0} created at {1} on thread #{2}.",
                                                                       data.Name, data.CreationTime, data.ThreadNum);
                                                   },
                                                  i );
          }
          Task.WaitAll(taskArray);
       }
    }
    // The example displays output like the following:
    //       Task #10 created at 635116418427727841 on thread #4.
    //       Task #10 created at 635116418427737842 on thread #4.
    //       Task #10 created at 635116418427737842 on thread #4.
    //       Task #10 created at 635116418427737842 on thread #4.
    //       Task #10 created at 635116418427737842 on thread #4.
    //       Task #10 created at 635116418427737842 on thread #4.
    //       Task #10 created at 635116418427727841 on thread #3.
    //       Task #10 created at 635116418427747843 on thread #3.
    //       Task #10 created at 635116418427747843 on thread #3.
    //       Task #10 created at 635116418427737842 on thread #4.

通过使用构造函数向任务提供状态对象，可以在每次迭代时访问该值。 以下示例在上一示例的基础上做了修改，在创建 `CustomData` 对象时使用循环计数器，该对象继而传递给 lambda 表达式。 如示例输出所示，每个 `CustomData` 对象现在都具有唯一的一个标识符，该标识符基于该对象实例化时循环计数器的值。

C\#复制

using System;
    using System.Threading;
    using System.Threading.Tasks;
    
    class CustomData
    {
       public long CreationTime;
       public int Name;
       public int ThreadNum;
    }
    
    public class Example
    {
       public static void Main()
       {
          // Create the task object by using an Action(Of Object) to pass in custom data
          // to the Task constructor. This is useful when you need to capture outer variables
          // from within a loop.
          Task[] taskArray = new Task[10];
          for (int i = 0; i < taskArray.Length; i++) {
             taskArray[i] = Task.Factory.StartNew( (Object obj ) => {
                                                      CustomData data = obj as CustomData;
                                                      if (data == null)
                                                         return;
    
                                                      data.ThreadNum = Thread.CurrentThread.ManagedThreadId;
                                                      Console.WriteLine("Task #{0} created at {1} on thread #{2}.",
                                                                       data.Name, data.CreationTime, data.ThreadNum);
                                                   },
                                                   new CustomData() {Name = i, CreationTime = DateTime.Now.Ticks} );
          }
          Task.WaitAll(taskArray);
       }
    }
    // The example displays output like the following:
    //       Task #0 created at 635116412924597583 on thread #3.
    //       Task #1 created at 635116412924607584 on thread #4.
    //       Task #3 created at 635116412924607584 on thread #4.
    //       Task #4 created at 635116412924607584 on thread #4.
    //       Task #2 created at 635116412924607584 on thread #3.
    //       Task #6 created at 635116412924607584 on thread #3.
    //       Task #5 created at 635116412924607584 on thread #4.
    //       Task #8 created at 635116412924607584 on thread #4.
    //       Task #7 created at 635116412924607584 on thread #3.
    //       Task #9 created at 635116412924607584 on thread #4.

此状态作为参数传递给任务委托，并且可通过使用 [Task.AsyncState][] 属性从任务对象访问。 以下示例在上一示例的基础上演变而来。 它使用 [AsyncState][Task.AsyncState] 属性显示关于传递到 lambda 表达式的 `CustomData` 对象的信息。

C\#复制

### 任务 ID ###

每个任务都获得一个在应用程序域中唯一标识自己的整数 ID，可以使用 [Task.Id][] 属性访问该 ID。 该 ID 可有效用于在 Visual Studio 调试器的“并行堆栈”和“任务”窗口中查看任务信息。 该 ID 是惰式创建的，这意味着它不会在被请求之前创建；因此每次运行该程序时，任务可能具有不同的 ID。 有关如何在调试器中查看任务 ID 的详细信息，请参阅[使用任务窗口][Link 2]和[使用并行堆栈窗口][Link 3]。

### 任务创建选项 ###

创建任务的大多数 API 提供接受 [TaskCreationOptions][] 参数的重载。 通过指定下列某个或多个选项，可指示任务计划程序在线程池中安排任务计划的方式。 可以使用位 OR 运算组合选项。

下面的示例演示一个具有 [LongRunning][] 和 [PreferFairness][] 选项的任务。

C\#复制

var task3 = new Task(() => MyLongRunningMethod(),
                        TaskCreationOptions.LongRunning | TaskCreationOptions.PreferFairness);
    task3.Start();

### 任务、线程和区域性 ###

每个线程都具有一个关联的区域性和 UI 区域性，分别由 [Thread.CurrentCulture][] 和 [Thread.CurrentUICulture][] 属性定义。 线程的区域性用在诸如格式、分析、排序和字符串比较操作中。 线程的 UI 区域性用于查找资源。

除非使用 [CultureInfo.DefaultThreadCurrentCulture][] 和 [CultureInfo.DefaultThreadCurrentUICulture][] 属性在应用程序域中为所有线程指定默认区域性，线程的默认区域性和 UI 区域性则由系统区域性定义。 如果你显式设置线程的区域性并启动新线程，则新线程不会继承正在调用的线程的区域性；相反，其区域性就是默认系统区域性。 但是，在基于任务的编程中，任务使用调用线程的区域性，即使任务在不同线程上以异步方式运行也是如此。

下面的示例提供了简单的演示。 它将应用的当前区域性更改为 French (France)；或者，如果 French (France) 已为当前区域性，则将其更改为 English (United States)。 然后，调用一个名为 `formatDelegate` 的委托，该委托返回在新区域性中格式化为货币值的数字。 无论委托是由任务同步调用还是异步调用，该任务都将使用调用线程的区域性。

C\#复制

using System;
    using System.Globalization;
    using System.Threading;
    using System.Threading.Tasks;
    
    public class Example
    {
       public static void Main()
       {
           decimal[] values = { 163025412.32m, 18905365.59m };
           string formatString = "C2";
           Func<String> formatDelegate = () => { string output = String.Format("Formatting using the {0} culture on thread {1}.\n",
                                                                               CultureInfo.CurrentCulture.Name,
                                                                               Thread.CurrentThread.ManagedThreadId);
                                                 foreach (var value in values)
                                                    output += String.Format("{0}   ", value.ToString(formatString));
    
                                                 output += Environment.NewLine;
                                                 return output;
                                               };
    
           Console.WriteLine("The example is running on thread {0}",
                             Thread.CurrentThread.ManagedThreadId);
           // Make the current culture different from the system culture.
           Console.WriteLine("The current culture is {0}",
                             CultureInfo.CurrentCulture.Name);
           if (CultureInfo.CurrentCulture.Name == "fr-FR")
              Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
           else
              Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR");
    
           Console.WriteLine("Changed the current culture to {0}.\n",
                             CultureInfo.CurrentCulture.Name);
    
           // Execute the delegate synchronously.
           Console.WriteLine("Executing the delegate synchronously:");
           Console.WriteLine(formatDelegate());
    
           // Call an async delegate to format the values using one format string.
           Console.WriteLine("Executing a task asynchronously:");
           var t1 = Task.Run(formatDelegate);
           Console.WriteLine(t1.Result);
    
           Console.WriteLine("Executing a task synchronously:");
           var t2 = new Task<String>(formatDelegate);
           t2.RunSynchronously();
           Console.WriteLine(t2.Result);
       }
    }
    // The example displays the following output:
    //         The example is running on thread 1
    //         The current culture is en-US
    //         Changed the current culture to fr-FR.
    //
    //         Executing the delegate synchronously:
    //         Formatting using the fr-FR culture on thread 1.
    //         163 025 412,32 €   18 905 365,59 €
    //
    //         Executing a task asynchronously:
    //         Formatting using the fr-FR culture on thread 3.
    //         163 025 412,32 €   18 905 365,59 €
    //
    //         Executing a task synchronously:
    //         Formatting using the fr-FR culture on thread 1.
    //         163 025 412,32 €   18 905 365,59 €

vbnet复制

Imports System.Globalization
    Imports System.Threading
    
    Module Example
        Public Sub Main()
            Dim values() As Decimal = {163025412.32D, 18905365.59D}
            Dim formatString As String = "C2"
            Dim formatDelegate As Func(Of String) = Function()
                                                        Dim output As String = String.Format("Formatting using the {0} culture on thread {1}.",
                                                                                             CultureInfo.CurrentCulture.Name,
                                                                                             Thread.CurrentThread.ManagedThreadId)
                                                        output += Environment.NewLine
                                                        For Each value In values
                                                            output += String.Format("{0}   ", value.ToString(formatString))
                                                        Next
                                                        output += Environment.NewLine
                                                        Return output
                                                    End Function
    
            Console.WriteLine("The example is running on thread {0}",
                              Thread.CurrentThread.ManagedThreadId)
            ' Make the current culture different from the system culture.
            Console.WriteLine("The current culture is {0}",
                              CultureInfo.CurrentCulture.Name)
            If CultureInfo.CurrentCulture.Name = "fr-FR" Then
                Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
            Else
                Thread.CurrentThread.CurrentCulture = New CultureInfo("fr-FR")
            End If
            Console.WriteLine("Changed the current culture to {0}.",
                              CultureInfo.CurrentCulture.Name)
            Console.WriteLine()
    
            ' Execute the delegate synchronously.
            Console.WriteLine("Executing the delegate synchronously:")
            Console.WriteLine(formatDelegate())
    
            ' Call an async delegate to format the values using one format string.
            Console.WriteLine("Executing a task asynchronously:")
            Dim t1 = Task.Run(formatDelegate)
            Console.WriteLine(t1.Result)
    
            Console.WriteLine("Executing a task synchronously:")
            Dim t2 = New Task(Of String)(formatDelegate)
            t2.RunSynchronously()
            Console.WriteLine(t2.Result)
        End Sub
    End Module
    
    ' The example displays the following output:
    '
    '          The example is running on thread 1
    '          The current culture is en-US
    '          Changed the current culture to fr-FR.
    '
    '          Executing the delegate synchronously:
    '          Formatting Imports the fr-FR culture on thread 1.
    '          163 025 412,32 €   18 905 365,59 €
    '
    '          Executing a task asynchronously:
    '          Formatting Imports the fr-FR culture on thread 3.
    '          163 025 412,32 €   18 905 365,59 €
    '
    '          Executing a task synchronously:
    '          Formatting Imports the fr-FR culture on thread 1.
    '          163 025 412,32 €   18 905 365,59 €

备注

在 .NET Framework 4.6 之前的 .NET Framework 版本中，任务的区域性由它在其上运行的线程区域性确定，而不是调用线程的区域性 。 对于异步任务，这意味着任务使用的区域性可能不同于调用线程的区域性。

有关异步任务和区域性的详细信息，请参阅 [CultureInfo][] 主题中的“区域性和基于异步任务的操作”部分。

### 创建任务延续 ###

使用 [Task.ContinueWith][] 和 [Task<TResult>.ContinueWith][Task_TResult_.ContinueWith] 方法，可以指定要在先行任务完成时启动的任务。 延续任务的委托已传递了对先行任务的引用，因此它可以检查先行任务的状态，并通过检索 [Task<TResult>.Result][Task_TResult_.Result] 属性的值将先行任务的输出用作延续任务的输入。

在下面的示例中，`getData` 任务通过调用 [TaskFactory.StartNew<TResult>(Func<TResult>)][TaskFactory.StartNew_TResult_Func_TResult] 方法来启动。 当 `processData` 完成时，`getData` 任务自动启动，当 `displayData` 完成时，`processData` 启动。 `getData` 产生一个整数数组，通过 `processData` 任务的 `getData` 属性，[Task<TResult>.Result][Task_TResult_.Result] 任务可访问该数组。 `processData` 任务处理该数组并返回结果，结果的类型从传递到 [Task<TResult>.ContinueWith<TNewResult>(Func<Task<TResult>,TNewResult>)][Task_TResult_.ContinueWith_TNewResult_Func_Task_TResult_TNewResult] 方法的 Lambda 表达式的返回类型推断而来。 `displayData` 完成时，`processData` 任务自动执行，而 [Tuple<T1,T2,T3>][Tuple_T1_T2_T3] 任务可通过 `processData` 任务的 `displayData` 属性访问由 `processData` lambda 表达式返回的 [Task<TResult>.Result][Task_TResult_.Result] 对象。 `displayData` 任务采用 `processData` 任务的结果，继而得出自己的结果，其类型以相似方式推断而来，且可由程序中的 [Result][Task_TResult_.Result] 属性使用。

C\#复制

using System;
    using System.Threading.Tasks;
    
    public class Example
    {
       public static void Main()
       {
          var getData = Task.Factory.StartNew(() => {
                                                 Random rnd = new Random();
                                                 int[] values = new int[100];
                                                 for (int ctr = 0; ctr <= values.GetUpperBound(0); ctr++)
                                                    values[ctr] = rnd.Next();
    
                                                 return values;
                                              } );
          var processData = getData.ContinueWith((x) => {
                                                    int n = x.Result.Length;
                                                    long sum = 0;
                                                    double mean;
    
                                                    for (int ctr = 0; ctr <= x.Result.GetUpperBound(0); ctr++)
                                                       sum += x.Result[ctr];
    
                                                    mean = sum / (double) n;
                                                    return Tuple.Create(n, sum, mean);
                                                 } );
          var displayData = processData.ContinueWith((x) => {
                                                        return String.Format("N={0:N0}, Total = {1:N0}, Mean = {2:N2}",
                                                                             x.Result.Item1, x.Result.Item2,
                                                                             x.Result.Item3);
                                                     } );
          Console.WriteLine(displayData.Result);
       }
    }
    // The example displays output similar to the following:
    //    N=100, Total = 110,081,653,682, Mean = 1,100,816,536.82

因为 [Task.ContinueWith][] 是实例方法，所以你可以将方法调用链接在一起，而不是为每个先行任务去实例化 [Task<TResult>][System.Threading.Tasks.Task_TResult] 对象。 以下示例与上一示例在功能上等同，唯一的不同在于它将对 [Task.ContinueWith][] 方法的调用链接在一起。 请注意，通过方法调用链返回的 [Task<TResult>][System.Threading.Tasks.Task_TResult] 对象是最终延续任务。

C\#复制

using System;
    using System.Threading.Tasks;
    
    public class Example
    {
       public static void Main()
       {
          var displayData = Task.Factory.StartNew(() => {
                                                     Random rnd = new Random();
                                                     int[] values = new int[100];
                                                     for (int ctr = 0; ctr <= values.GetUpperBound(0); ctr++)
                                                        values[ctr] = rnd.Next();
    
                                                     return values;
                                                  } ).
                            ContinueWith((x) => {
                                            int n = x.Result.Length;
                                            long sum = 0;
                                            double mean;
    
                                            for (int ctr = 0; ctr <= x.Result.GetUpperBound(0); ctr++)
                                               sum += x.Result[ctr];
    
                                            mean = sum / (double) n;
                                            return Tuple.Create(n, sum, mean);
                                         } ).
                            ContinueWith((x) => {
                                            return String.Format("N={0:N0}, Total = {1:N0}, Mean = {2:N2}",
                                                                 x.Result.Item1, x.Result.Item2,
                                                                 x.Result.Item3);
                                         } );
          Console.WriteLine(displayData.Result);
       }
    }
    // The example displays output similar to the following:
    //    N=100, Total = 110,081,653,682, Mean = 1,100,816,536.82

使用 [ContinueWhenAll][] 和 [ContinueWhenAny][] 方法，可以从多个任务继续。

有关详细信息，请参阅[使用延续任务链接任务][Link 4]。

### 创建分离的子任务 ###

如果在任务中运行的用户代码创建一个新任务，且未指定 [AttachedToParent][] 选项，则该新任务不采用任何特殊方式与父任务同步。 这种不同步的任务类型称为“分离的嵌套任务”或“分离的子任务”。 以下示例展示了创建一个分离子任务的任务。

C\#复制

var outer = Task.Factory.StartNew(() =>
    {
        Console.WriteLine("Outer task beginning.");
    
        var child = Task.Factory.StartNew(() =>
        {
            Thread.SpinWait(5000000);
            Console.WriteLine("Detached task completed.");
        });
    });
    
    outer.Wait();
    Console.WriteLine("Outer task completed.");
    // The example displays the following output:
    //    Outer task beginning.
    //    Outer task completed.
    //    Detached task completed.

请注意，父任务不会等待分离子任务完成。

### 创建子任务 ###

如果任务中运行的用户代码在创建任务时指定了 [AttachedToParent][] 选项，新任务就称为父任务的附加子任务。 因为父任务隐式地等待所有附加子任务完成，所以你可以使用 [AttachedToParent][] 选项表示结构化的任务并行。 以下示例展示了创建十个附加子任务的父任务。 请注意，虽然此示例调用 [Task.Wait][] 方法等待父任务完成，但不必显式等待附加子任务完成。

C\#复制

using System;
    using System.Threading;
    using System.Threading.Tasks;
    
    public class Example
    {
       public static void Main()
       {
          var parent = Task.Factory.StartNew(() => {
                          Console.WriteLine("Parent task beginning.");
                          for (int ctr = 0; ctr < 10; ctr++) {
                             int taskNo = ctr;
                             Task.Factory.StartNew((x) => {
                                                      Thread.SpinWait(5000000);
                                                      Console.WriteLine("Attached child #{0} completed.",
                                                                        x);
                                                   },
                                                   taskNo, TaskCreationOptions.AttachedToParent);
                          }
                       });
    
          parent.Wait();
          Console.WriteLine("Parent task completed.");
       }
    }
    // The example displays output like the following:
    //       Parent task beginning.
    //       Attached child #9 completed.
    //       Attached child #0 completed.
    //       Attached child #8 completed.
    //       Attached child #1 completed.
    //       Attached child #7 completed.
    //       Attached child #2 completed.
    //       Attached child #6 completed.
    //       Attached child #3 completed.
    //       Attached child #5 completed.
    //       Attached child #4 completed.
    //       Parent task completed.

父任务可使用 [TaskCreationOptions.DenyChildAttach][] 选项阻止其他任务附加到父任务。 有关详细信息，请参阅[附加和分离的子任务][Link 5]。

### 等待任务完成 ###

[System.Threading.Tasks.Task][Task] 和 [System.Threading.Tasks.Task<TResult>][System.Threading.Tasks.Task_TResult] 类型提供了 [Task.Wait][] 方法的若干重载，以便能够等待任务完成。 此外，使用静态 [Task.WaitAll][] 和 [Task.WaitAny][] 方法的重载可以等待一批任务中的任一任务或所有任务完成。

通常，会出于以下某个原因等待任务：

*  主线程依赖于任务计算的最终结果。
 *  你必须处理可能从任务引发的异常。
 *  应用程序可以在所有任务执行完毕之前终止。 例如，执行 `Main`（应用程序入口点）中的所有同步代码后，控制台应用程序将立即终止。

下面的示例演示不包含异常处理的基本模式。

C\#复制

Task[] tasks = new Task[3]
    {
        Task.Factory.StartNew(() => MethodA()),
        Task.Factory.StartNew(() => MethodB()),
        Task.Factory.StartNew(() => MethodC())
    };
    
    //Block until all tasks complete.
    Task.WaitAll(tasks);
    
    // Continue on this thread...

有关演示异常处理的示例，请参见[异常处理][Link 6]。

某些重载允许你指定超时，而其他重载采用额外的 [CancellationToken][] 作为输入参数，以便可以通过编程方式或根据用户输入来取消等待。

等待任务时，其实是在隐式等待使用 [TaskCreationOptions.AttachedToParent][AttachedToParent] 选项创建的该任务的所有子级。 [Task.Wait][] 在该任务已完成时立即返回。 [Task.Wait][] 方法将抛出由某任务引发的任何异常，即使 [Task.Wait][] 方法是在该任务完成之后调用的。

### 组合任务 ###

[Task][] 类和 [Task<TResult>][System.Threading.Tasks.Task_TResult] 类提供多种方法，这些方法能够帮助你组合多个任务以实现常见模式，并更好地使用由 C\#、Visual Basic 和 F\# 提供的异步语言功能。 本节介绍了 [WhenAll][]、[WhenAny][]、[Delay][] 和 [FromResult][] 方法。

#### Task.WhenAll ####

[Task.WhenAll][WhenAll] 方法异步等待多个 [Task][] 或 [Task<TResult>][System.Threading.Tasks.Task_TResult] 对象完成。 通过它提供的重载版本可以等待非均匀任务组。 例如，你可以等待多个 [Task][] 和 [Task<TResult>][System.Threading.Tasks.Task_TResult] 对象在一个方法调用中完成。

#### Task.WhenAny ####

[Task.WhenAny][WhenAny] 方法异步等待多个 [Task][] 或 [Task<TResult>][System.Threading.Tasks.Task_TResult] 对象中的一个完成。 与在 [Task.WhenAll][WhenAll] 方法中一样，该方法提供重载版本，让你能等待非均匀任务组。 [WhenAny][] 方法在下列情境中尤其有用。

*  冗余运算。 请考虑可以用多种方式执行的算法或运算。 你可使用 [WhenAny][] 方法来选择先完成的运算，然后取消剩余的运算。
 *  交叉运算。 你可启动必须全部完成的多项运算，并使用 [WhenAny][] 方法在每项运算完成时处理结果。 在一项运算完成后，可以启动一个或多个其他任务。
 *  受限制的运算。 你可使用 [WhenAny][] 方法通过限制并发运算的数量来扩展前面的情境。
 *  过期的运算。 你可使用 [WhenAny][] 方法在一个或多个任务与特定时间后完成的任务（例如 [Delay][] 方法返回的任务）间进行选择。 下节描述了 [Delay][] 方法。

#### Task.Delay ####

[Task.Delay][Delay] 方法将生成在指定时间后完成的 [Task][] 对象。 你可使用此方法来生成偶尔轮询数据的循环，引入超时，将对用户输入的处理延迟预定的一段时间等。

#### Task(T).FromResult ####

通过使用 [Task.FromResult][FromResult] 方法，你可以创建包含预计算结果的 [Task<TResult>][System.Threading.Tasks.Task_TResult] 对象。 执行返回 [Task<TResult>][System.Threading.Tasks.Task_TResult] 对象的异步运算，且已计算该 [Task<TResult>][System.Threading.Tasks.Task_TResult] 对象的结果时，此方法将十分有用。 有关使用 [FromResult][] 检索缓存中包含的异步下载运算结果的示例，请参阅[如何：创建预先计算的任务][Link 7]。

### 处理任务中的异常 ###

当某个任务抛出一个或多个异常时，异常包装在 [AggregateException][] 异常中。 该异常传播回与该任务联接的线程，通常该线程正在等待该任务完成或该线程访问 [Result][Task_TResult_.Result] 属性。 此行为用于强制实施 .NET Framework 策略 - 默认所有未处理的异常应终止进程。 调用代码可以通过使用 `try`/`catch` 块中的以下任意方法来处理异常：

*  [Wait][Task.Wait] 方法
 *  [WaitAll][Task.WaitAll] 方法
 *  [WaitAny][Task.WaitAny] 方法
 *  [Result][Task_TResult_.Result] 属性

联接线程也可以通过在对任务进行垃圾回收之前访问 [Exception][] 属性来处理异常。 通过访问此属性，可防止未处理的异常在对象完成时触发终止进程的异常传播行为。

有关异常和任务的的详细信息，请参阅[异常处理][Link 6]。

### 取消任务 ###

[Task][] 类支持协作取消，并与 .NET Framework 4 中新增的 [System.Threading.CancellationTokenSource][] 类和 [System.Threading.CancellationToken][CancellationToken] 类完全集成。 [System.Threading.Tasks.Task][Task] 类中的大多数构造函数采用 [CancellationToken][] 对象作为输入参数。 许多 [StartNew][TaskFactory.StartNew] 和 [Run][Task.Run] 重载还包括 [CancellationToken][] 参数。

你可以创建标记，并使用 [CancellationTokenSource][System.Threading.CancellationTokenSource] 类在以后某一时间发出取消请求。 可以将该标记作为参数传递给 [Task][]，还可以在执行响应取消请求的工作的用户委托中引用同一标记。

有关详细信息，请参阅[任务取消][Link 8]和[如何：取消任务及其子级][Link 9]。

### TaskFactory 类 ###

[TaskFactory][] 类提供静态方法，这些方法封装了用于创建和启动任务和延续任务的一些常用模式。

*  最常用模式为 [StartNew][TaskFactory.StartNew]，它在一个语句中创建并启动任务。
 *  如果通过多个先行任务创建延续任务，请使用 [ContinueWhenAll][] 方法或 [ContinueWhenAny][] 方法，或它们在 [Task<TResult>][System.Threading.Tasks.Task_TResult] 类中的相当方法。 有关详细信息，请参阅[使用延续任务链接任务][Link 4]。
 *  若要在 `BeginX` 或 `EndX` 实例中封装异步编程模型 [Task][] 和 [Task<TResult>][System.Threading.Tasks.Task_TResult] 方法，请使用 [FromAsync][] 方法。 有关详细信息，请参阅 [TPL 和传统 .NET Framework 异步编程][TPL _ .NET Framework]。

默认的 [TaskFactory][] 可作为 [Task][] 类或 [Task<TResult>][System.Threading.Tasks.Task_TResult] 类上的静态属性访问。 你还可以直接实例化 [TaskFactory][] 并指定各种选项，包括 [CancellationToken][]、[TaskCreationOptions][] 选项、[TaskContinuationOptions][] 选项或 [TaskScheduler][]。 创建任务工厂时所指定的任何选项将应用于它创建的所有任务，除非 [Task][] 是通过使用 [TaskCreationOptions][] 枚举创建的（在这种情况下，任务的选项重写任务工厂的选项）。

### 无委托的任务 ###

在某些情况下，可能需要使用 [Task][] 封装由外部组件（而不是你自己的用户委托）执行的某个异步操作。 如果该操作基于异步编程模型 Begin/End 模式，你可以使用 [FromAsync][] 方法。 如果不是这种情况，你可以使用 [TaskCompletionSource<TResult>][TaskCompletionSource_TResult] 对象将该操作包装在任务中，并因而获得 [Task][] 可编程性的一些好处，例如对异常传播和延续的支持。 有关详细信息，请参阅 [TaskCompletionSource<TResult>][TaskCompletionSource_TResult]。

### 自定义计划程序 ###

大多数应用程序或库开发人员并不关心任务在哪个处理器上运行、任务如何将其工作与其他任务同步以及如何在 [System.Threading.ThreadPool][ThreadPool] 中计划任务。 他们只需要它在主机上尽可能高效地执行。 如果需要对计划细节进行更细化的控制，可以使用任务并行库在默认任务计划程序上配置一些设置，甚至是提供自定义计划程序。 有关详细信息，请参阅 [TaskScheduler][]。

### 相关数据结构 ###

TPL 有几种在并行和顺序方案中都有用的新公共类型。 它们包括 [System.Collections.Concurrent][] 命名空间中的一些线程安全的、快速且可缩放的集合类，还包括一些新的同步类型（例如 [System.Threading.Semaphore][] 和 [System.Threading.ManualResetEventSlim][]），对特定类型的工作负荷而言，这些新同步类型比旧的同步类型效率更高。 .NET Framework 4 中的其他新类型（例如 [System.Threading.Barrier][] 和 [System.Threading.SpinLock][]）提供了早期版本中未提供的功能。 有关详细信息，请参阅[用于并行编程的数据结构][Link 10]。

### 自定义任务类型 ###

建议不要从 [System.Threading.Tasks.Task][Task] 或 [System.Threading.Tasks.Task<TResult>][System.Threading.Tasks.Task_TResult] 继承。 相反，我们建议你使用 [AsyncState][Task.AsyncState] 属性将其他数据或状态与 [Task][] 或 [Task<TResult>][System.Threading.Tasks.Task_TResult] 对象相关联。 还可以使用扩展方法扩展 [Task][] 和 [Task<TResult>][System.Threading.Tasks.Task_TResult] 类的功能。 有关扩展方法的详细信息，请参阅[扩展方法][Link 11]和[扩展方法][Link 12]。

如果必须从 [Task][] 或 [Task<TResult>][System.Threading.Tasks.Task_TResult] 继承，则不能使用 [Run][Task.Run] 或 [System.Threading.Tasks.TaskFactory][TaskFactory]，[System.Threading.Tasks.TaskFactory<TResult>][System.Threading.Tasks.TaskFactory_TResult] 或 [System.Threading.Tasks.TaskCompletionSource<TResult>][TaskCompletionSource_TResult] 类创建自定义任务类型的实例，因为这些类仅创建 [Task][] 和 [Task<TResult>][System.Threading.Tasks.Task_TResult] 对象。 此外，不能使用 [Task][]、[Task<TResult>][System.Threading.Tasks.Task_TResult]、[TaskFactory][] 和 [TaskFactory<TResult>][System.Threading.Tasks.TaskFactory_TResult] 提供的任务延续机制创建自定义任务类型的实例，因为这些机制也只创建 [Task][] 和 [Task<TResult>][System.Threading.Tasks.Task_TResult] 对象。

### 相关主题 ###

<table>  相关主题  
 <thead> 
  <tr> 
   <th>Title</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/chaining-tasks-by-using-continuation-tasks" title="使用延续任务来链接任务" rel="nofollow">使用延续任务来链接任务</a></td> 
   <td>描述延续任务的工作方式。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/attached-and-detached-child-tasks" title="附加和分离的子任务" rel="nofollow">附加和分离的子任务</a></td> 
   <td>描述附加子任务和分离子任务之间的差异。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/task-cancellation" title="任务取消" rel="nofollow">任务取消</a></td> 
   <td>描述在&nbsp;<a href="https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task" title="Task" rel="nofollow">Task</a>&nbsp;对象中内置的取消支持。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/exception-handling-task-parallel-library" title="异常处理" rel="nofollow">异常处理</a></td> 
   <td>描述如何处理并行线程中的异常。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/how-to-use-parallel-invoke-to-execute-parallel-operations" title="如何：使用 Parallel.Invoke 来执行并行操作" rel="nofollow">如何：使用 Parallel.Invoke 来执行并行操作</a></td> 
   <td>描述如何使用&nbsp;<a href="https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.parallel.invoke" title="Invoke" rel="nofollow">Invoke</a>。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/how-to-return-a-value-from-a-task" title="如何：从任务中返回值" rel="nofollow">如何：从任务中返回值</a></td> 
   <td>描述如何从任务中返回值。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/how-to-cancel-a-task-and-its-children" title="如何：取消任务及其子级" rel="nofollow">如何：取消任务及其子级</a></td> 
   <td>描述如何取消任务。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/how-to-create-pre-computed-tasks" title="如何：创建预先计算的任务" rel="nofollow">如何：创建预先计算的任务</a></td> 
   <td>描述如何使用&nbsp;<a href="https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.fromresult" title="Task.FromResult" rel="nofollow">Task.FromResult</a>&nbsp;方法去检索缓存中包含的异步下载运算结果。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/how-to-traverse-a-binary-tree-with-parallel-tasks" title="如何：使用并行任务遍历二叉树" rel="nofollow">如何：使用并行任务遍历二叉树</a></td> 
   <td>描述如何使用任务遍历二叉树。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/how-to-unwrap-a-nested-task" title="如何：解除嵌套任务的包装" rel="nofollow">如何：解除嵌套任务的包装</a></td> 
   <td>演示如何使用&nbsp;<a href="https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskextensions.unwrap" title="Unwrap" rel="nofollow">Unwrap</a>&nbsp;扩展方法。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/data-parallelism-task-parallel-library" title="数据并行" rel="nofollow">数据并行</a></td> 
   <td>描述如何使用&nbsp;<a href="https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.parallel.for" title="For" rel="nofollow">For</a>&nbsp;和&nbsp;<a href="https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.parallel.foreach" title="ForEach" rel="nofollow">ForEach</a>&nbsp;来创建循环访问数据的并行循环。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/" title="并行编程" rel="nofollow">并行编程</a></td> 
   <td>.NET Framework 并行编程的顶级节点。</td> 
  </tr> 
 </tbody> 
</table>

### 请参阅 ###

*  [并行编程][Link 13]
 *  [使用 .NET Core 和 .NET Standard 并行编程的示例][.NET Core _ .NET Standard]

[ThreadPool]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.threadpool
[Parallel.Invoke]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.parallel.invoke
[Action]: https://docs.microsoft.com/zh-cn/dotnet/api/system.action
[PLINQ _ TPL _ Lambda]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/lambda-expressions-in-plinq-and-tpl
[Task]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task
[Parallel.Invoke 1]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/how-to-use-parallel-invoke-to-execute-parallel-operations
[System.Threading.Tasks.Task_TResult]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task-1
[Status]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.status
[TaskStatus]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskstatus
[Task.Wait]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.wait
[Task.Run]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.run
[TaskFactory.StartNew]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskfactory.startnew
[Task.AsyncState]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.asyncstate
[Factory]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.factory
[TaskFactory]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskfactory
[Task_TResult_.Result]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task-1.result
[Link 1]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/how-to-return-a-value-from-a-task
[Task.Id]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.id
[Link 2]: https://docs.microsoft.com/zh-cn/visualstudio/debugger/using-the-tasks-window
[Link 3]: https://docs.microsoft.com/zh-cn/visualstudio/debugger/using-the-parallel-stacks-window
[TaskCreationOptions]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskcreationoptions
[LongRunning]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskcreationoptions#system-threading-tasks-taskcreationoptions-longrunning
[PreferFairness]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskcontinuationoptions#system-threading-tasks-taskcontinuationoptions-preferfairness
[Thread.CurrentCulture]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.thread.currentculture
[Thread.CurrentUICulture]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.thread.currentuiculture
[CultureInfo.DefaultThreadCurrentCulture]: https://docs.microsoft.com/zh-cn/dotnet/api/system.globalization.cultureinfo.defaultthreadcurrentculture
[CultureInfo.DefaultThreadCurrentUICulture]: https://docs.microsoft.com/zh-cn/dotnet/api/system.globalization.cultureinfo.defaultthreadcurrentuiculture
[CultureInfo]: https://docs.microsoft.com/zh-cn/dotnet/api/system.globalization.cultureinfo
[Task.ContinueWith]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.continuewith
[Task_TResult_.ContinueWith]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task-1.continuewith
[TaskFactory.StartNew_TResult_Func_TResult]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskfactory.startnew#system-threading-tasks-taskfactory-startnew-1%28system-func%28%28-0%29%29%29
[Task_TResult_.ContinueWith_TNewResult_Func_Task_TResult_TNewResult]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task-1.continuewith#system-threading-tasks-task-1-continuewith-1%28system-func%28%28system-threading-tasks-task%28%28-0%29%29-0%29%29%29
[Tuple_T1_T2_T3]: https://docs.microsoft.com/zh-cn/dotnet/api/system.tuple-3
[ContinueWhenAll]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskfactory.continuewhenall
[ContinueWhenAny]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskfactory.continuewhenany
[Link 4]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/chaining-tasks-by-using-continuation-tasks
[AttachedToParent]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskcreationoptions#system-threading-tasks-taskcreationoptions-attachedtoparent
[TaskCreationOptions.DenyChildAttach]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskcreationoptions#system-threading-tasks-taskcreationoptions-denychildattach
[Link 5]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/attached-and-detached-child-tasks
[Task.WaitAll]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.waitall
[Task.WaitAny]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.waitany
[Link 6]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/exception-handling-task-parallel-library
[CancellationToken]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.cancellationtoken
[WhenAll]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.whenall
[WhenAny]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.whenany
[Delay]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.delay
[FromResult]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.fromresult
[Link 7]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/how-to-create-pre-computed-tasks
[AggregateException]: https://docs.microsoft.com/zh-cn/dotnet/api/system.aggregateexception
[Exception]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.exception
[System.Threading.CancellationTokenSource]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.cancellationtokensource
[Link 8]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/task-cancellation
[Link 9]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/how-to-cancel-a-task-and-its-children
[FromAsync]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskfactory.fromasync
[TPL _ .NET Framework]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/tpl-and-traditional-async-programming
[TaskContinuationOptions]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskcontinuationoptions
[TaskScheduler]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskscheduler
[TaskCompletionSource_TResult]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskcompletionsource-1
[System.Collections.Concurrent]: https://docs.microsoft.com/zh-cn/dotnet/api/system.collections.concurrent
[System.Threading.Semaphore]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.semaphore
[System.Threading.ManualResetEventSlim]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.manualreseteventslim
[System.Threading.Barrier]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.barrier
[System.Threading.SpinLock]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.spinlock
[Link 10]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/data-structures-for-parallel-programming
[Link 11]: https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/classes-and-structs/extension-methods
[Link 12]: https://docs.microsoft.com/zh-cn/dotnet/visual-basic/programming-guide/language-features/procedures/extension-methods
[System.Threading.Tasks.TaskFactory_TResult]: https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskfactory-1
[Link 13]: https://docs.microsoft.com/zh-cn/dotnet/standard/parallel-programming/
[.NET Core _ .NET Standard]: https://docs.microsoft.com/zh-cn/samples/browse/?products=dotnet-core%2Cdotnet-standard&term=parallel