Task

一、Task是任务，不是线程，但是执行的时候是需要线程；任务跟线程不是一对一的关系，比如开3个任务并不是说会开3个线程

在上一篇并行编程_Parallel文章中，反编译看了下源码Parallel.Invoke，会创建与调用的action[]数目一致的System.Threading.Tasks.Task的实例;Parallel.For、Parallel.ForEach的循环迭代的并行执行,也会创建Task实例

对于构造函数,属性,方法介绍看微软这篇msdn文档:https://msdn.microsoft.com/zh-cn/library/system.threading.tasks.task(v=vs.110).aspx

二、Task示例

1.0 创建和执行任务

#region 创建和执行任务
            // Task.Run
            Task task = Task.Run(() =>
               {
                   // Just loop.
                   int ctr = 0;
                   for (ctr = 0; ctr <= 1000000; ctr++) { }
                   Console.WriteLine("Finished {0} loop iterations", ctr);
               });
            Console.WriteLine("可能接着执行到这儿");
            task.Wait();
            Console.ReadKey();


           //Task.Factory.StartNew
             Task task = Task.Factory.StartNew(() =>
            {
                // Just loop.
                int ctr = 0;
                for (ctr = 0; ctr <= 1000000; ctr++){ }
                Console.WriteLine("Finished {0} loop iterations",ctr);
            });
            task.Wait();
            Console.ReadKey();
            #endregion 创建和执行任务

2.0等待一个或多个任务完成，还有 ContinueWhenAll 方法等待一组方法全部完成在继续工作；

#region 等待一个或多个任务完成
            //1.0Task.Wait
            Task taskA = Task.Run(() => { Thread.Sleep(2000); });
            Console.WriteLine("taskA Status: {0}", taskA.Status);//WaitingToRun
            try
            {
                taskA.Wait();
                Console.WriteLine("taskA Status: {0}", taskA.Status);//RanToCompletion
            }
            catch (AggregateException)
            {
                Console.WriteLine("Exception in taskA.");

            }
            Console.ReadKey();



          //2.0  Task.Wait(1000)
           Task taskA = Task.Run(() => { Thread.Sleep(3000);});
            try
            {
                taskA.Wait(1000);  // Wait for 1 second.main thread continue
                bool completed = taskA.IsCompleted;//false
                Console.WriteLine("taskA Status: {0}", taskA.Status);
                if (!completed)
                {
                    Console.WriteLine("Time out before task A completed.");
                }
            }
            catch (AggregateException)
            {
                Console.WriteLine("Exception in taskA.");

            }


            //3.0Task.WaitAny,Task.WaitAll
             var tasks = new Task[3];
            var rnd = new Random();
            for (int i = 0; i < 3; i++)
            {
                tasks[i] = Task.Run(() => { Thread.Sleep(rnd.Next(500, 3000)); });
            }
            try
            {
                //等待哪个先完成就返回哪个任务的索引;
                int index = Task.WaitAny(tasks);
                Console.WriteLine("Task #{0} completed first.
", tasks[index].Id); //Task #1 completed first.
                Console.WriteLine("Status of all tasks:");
                foreach (var t in tasks)
                {
                    //Task #3: Running
                    //Task #4: Running
                    //Task #1: RanToCompletion
                    Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
                }
                Task.WaitAll(tasks);//等待所有任务完成
                foreach (var t in tasks)
                {
                    //Task #3: RanToCompletion
                    //Task #4: RanToCompletion
                    //Task #1: RanToCompletion
                    Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
                }
            }
            catch (AggregateException)
            {
                Console.WriteLine("An exception occurred.");
            }
            Console.ReadKey();




 #endregion

3.0 异常处理示例, 参考:https://msdn.microsoft.com/zh-cn/library/dd997415(v=vs.110).aspx，try-catch,ContinueWith==>IsFaulted

示例：其它可查看第二篇的TaskCompletionSource，有些：http://www.cnblogs.com/entclark/p/8047323.html

// Create a cancellation token and cancel it.
            var source1 = new CancellationTokenSource();
            var token1 = source1.Token;
            source1.Cancel();
            // Create a cancellation token for later cancellation.
            var source2 = new CancellationTokenSource();
            var token2 = source2.Token;

            // Create a series of tasks that will complete, be cancelled, timeout, or throw an exception.
            Task[] tasks = new Task[12];
            for (int i = 0; i < 12; i++)
            {
                switch (i % 4)
                {
                    // Task should run to completion.
                    case 0:
                        tasks[i] = Task.Run(() => Thread.Sleep(2000));
                        break;
                    // Task should be set to canceled state.
                    case 1:
                        tasks[i] = Task.Run(() => Thread.Sleep(2000),
                                 token1);
                        break;

                    case 2:
                        // Task should throw an exception.
                        tasks[i] = Task.Run(() => { throw new NotSupportedException(); });
                        break;

                    case 3:
                        // Task should examine cancellation token.
                        tasks[i] = Task.Run(() =>
                        {
                            Thread.Sleep(2000);
                            if (token2.IsCancellationRequested)
                                token2.ThrowIfCancellationRequested();
                            Thread.Sleep(500);
                        }, token2);
                        break;
                }
            }
            Thread.Sleep(250);
            source2.Cancel();

            try
            {
                Task.WaitAll(tasks);
            }
            catch (AggregateException ae)//一般使用累加异常,不用出现第一个异常就跳到这里面,影响其他任务继续运行
            {
                Console.WriteLine("One or more exceptions occurred:");
                foreach (var ex in ae.InnerExceptions)
                    Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message);
            }

            Console.WriteLine("
Status of tasks:");
            foreach (var t in tasks)
            {
                Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
                if (t.Exception != null)
                {
                    foreach (var ex in t.Exception.InnerExceptions)
                        Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                          ex.Message);
                }
            }
            Console.ReadKey();

4.0 任务和区域性

//下面的示例创建并执行四项任务。 三个任务执行 Action< T > 委托名为 action, ，这样便可以接受类型的参数 Object。
            //任务 t1 实例化时通过调用任务类构造函数，但通过调用会启动其 Start() 方法仅在任务后的 t2 已启动。
            //任务 t2 会实例化并通过调用单个方法调用中启动 TaskFactory.StartNew(Action<Object>, Object) 方法。
            //任务 t3 会实例化并通过调用单个方法调用中启动 Run(Action) 方法。
            //任务 t4 上同步执行主线程通过调用 RunSynchronously() 方法。
            Action <object> action = (object obj) =>
            {
                Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                Task.CurrentId, obj,
                Thread.CurrentThread.ManagedThreadId);
            };

            // Create a task but do not start it.
            Task t1 = new Task(action, "alpha");

            // Construct a started task
            Task t2 = Task.Factory.StartNew(action, "beta");
            // Block the main thread to demonstate that t2 is executing
            t2.Wait();

            // Launch t1 
            t1.Start();
            Console.WriteLine("t1 has been launched. (Main Thread={0})",
                              Thread.CurrentThread.ManagedThreadId);
            // Wait for the task to finish.
            t1.Wait();

            // Construct a started task using Task.Run.
            String taskData = "delta";
            Task t3 = Task.Run(() => {
                Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                  Task.CurrentId, taskData,
                                   Thread.CurrentThread.ManagedThreadId);
            });
            // Wait for the task to finish.
            t3.Wait();

            // Construct an unstarted task
            Task t4 = new Task(action, "gamma");
            // Run it synchronously
            t4.RunSynchronously();
            // Although the task was run synchronously, it is a good practice
            // to wait for it in the event exceptions were thrown by the task.
            t4.Wait();
            Console.ReadKey();

三、Task<TResult>示例,一个可以返回值的异步操作。获取结果的时候必须等待操作完成，t.Result

//备注:Task<TResult> 类的表示单个操作通常返回一个值，并以异步方式执行。 Task<TResult> 对象是一种.NET Framework 4 中引入的第一个主要的组件。
//因为由执行工作 Task<TResult> 对象通常以异步方式执行在线程池线程上而不是以同步方式在主应用程序线程，您可以使用 Status 属性，以及 IsCanceled, 
//IsCompleted, ，和 IsFaulted 属性，以确定任务的状态。 大多数情况下，lambda 表达式用于指定的任务是执行的工作。
//Task<TResult> 可以多种方式创建实例。 最常用的方法，是调用静态 Task.Run<TResult>(Func<TResult>) 或 Task.Run<TResult>(Func<TResult>, CancellationToken) 
//方法。 这些方法提供简单的方法来启动任务，通过使用默认值，而无需获取其他参数。

var t = Task.Run(() =>
            {
                // Just loop.
                int max = 1000000;
                int ctr = 0;
                for (ctr = 0; ctr <= max; ctr++)
                {
                    if (ctr == max / 2 && DateTime.Now.Hour <= 12)
                    {
                        ctr++;
                        break;
                    }
                }
                Thread.Sleep(2000);
                return ctr;

            });
            //主线程继续
            Console.WriteLine("....");
            //必须等待输出结果,阻塞主线程
            Console.WriteLine("Finished {0:N0} iterations.",t.Result);
            //主线程继续
            Console.WriteLine("....");
            Console.ReadKey();

Task

var t = Task<int>.Factory.StartNew(() =>
            {
                // Just loop.
                int max = 1000000;
                int ctr = 0;
                for (ctr = 0; ctr <= max; ctr++)
                {
                    if (ctr == max / 2 && DateTime.Now.Hour <= 12)
                    {
                        ctr++;
                        break;
                    }
                }
                Thread.Sleep(2000);
                return ctr;
            });
            //主线程继续
            Console.WriteLine("....");
            //必须等待输出结果,阻塞主线程
            Console.WriteLine("Finished {0:N0} iterations.", t.Result);
            //主线程继续
            Console.WriteLine("....");
            Console.ReadKey();

TaskFactory

//一次使用的方法,使用匿名方法或者委托或者lambda代替,多次只在本方法体中使用就用委托
            Func<double, double> doComputation = (start) =>
            {
                Double sum = 0;
                for (var value = start; value <= start + 10; value += .1)
                    sum += value;

                return sum;
            };
            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 sum2 = 0.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 ? "= " : "+ ");
                sum2 += results[i];
            }
            Console.WriteLine("{0:N1}", sum2);
            Console.ReadKey();

四、创建任务延续

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

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);

   //创建一个任务，在数组中的任务之一通过调用完成后开始 ContinueWhenAny 方法。
   //创建一个任务，在数组中的所有任务已都完成通过调用开始 ContinueWhenAll 方法。比较常用

 Task<string[]>[] tasks = new Task<string[]>[2];
            string docsDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            tasks[0] = Task<string[]>.Factory.StartNew(() => Directory.GetFiles(docsDirectory));
            tasks[1] = Task<string[]>.Factory.StartNew(() => Directory.GetDirectories(docsDirectory));
            Task.Factory.ContinueWhenAll(tasks, completedTasks =>
            {
                Console.WriteLine("{0} contains: ", docsDirectory);
                Console.WriteLine("   {0} subdirectories", tasks[1].Result.Length);
                Console.WriteLine("   {0} files", tasks[0].Result.Length);
            });
            Console.ReadKey();

五、创建子任务

1、分离的主任务：如果在任务中运行的用户代码创建一个新任务，且未指定 AttachedToParent 选项，则该新任务不采用任何特殊方式与父任务同步。 这种不同步的任务类型称为“分离的嵌套任务”或“分离的子任务”；请注意，默认父任务不会等待分离子任务完成，因为跟我们在主线程中开一个任务一样，不等待宿主线程；

   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.");
            Console.ReadKey();
  // The example displays the following output:
            //    Outer task beginning.
            //    Outer task completed.
            //    Detached task completed.

2、创建不分离的子任务（父任务等待子任务，创建或者调用静态方法开启任务时可以指定TaskCreationOptions.AttachedToParent附加到父类）

  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.");
            Console.ReadKey();
            // 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.

六、组合任务介绍

  // Task.WhenAll
            //Task.WhenAll 方法异步等待多个 Task 或 Task<TResult> 对象完成。 通过它提供的重载版本可以等待非均匀任务组。 例如，你可以等待多个 Task 和 Task<TResult> 对象在一个方法调用中完成。
            //Task.WhenAny
            //Task.WhenAny 方法异步等待多个 Task 或 Task<TResult> 对象中的一个完成。 与在 Task.WhenAll 方法中一样，该方法提供重载版本，让你能等待非均匀任务组。 WhenAny 方法在下列情境中尤其有用。
            //冗余运算。 请考虑可以用多种方式执行的算法或运算。 你可使用 WhenAny 方法来选择先完成的运算，然后取消剩余的运算。
            //交叉运算。 你可启动必须全部完成的多项运算，并使用 WhenAny 方法在每项运算完成时处理结果。 在一项运算完成后，可以启动一个或多个其他任务。
            //受限制的运算。 你可使用 WhenAny 方法通过限制并发运算的数量来扩展前面的情境。
            //过期的运算。 你可使用 WhenAny 方法在一个或多个任务与特定时间后完成的任务（例如 Delay 方法返回的任务）间进行选择。 下节描述了 Delay 方法。
            //Task.Delay
            //Task.Delay 方法将生成在指定时间后完成的 Task 对象。 你可使用此方法来生成偶尔轮询数据的循环，引入超时，将对用户输入的处理延迟预定的一段时间等。
            //Task(T).FromResult
            //通过使用 Task.FromResult<TResult> 方法，你可以创建包含预计算结果的 Task<TResult> 对象。 执行返回 Task<TResult> 对象的异步运算，且已计算该 Task<TResult> 对象的结果时，此方法将十分有用。 对于使用 FromResult<TResult> 来检索缓存中包含的异步下载操作结果，可参考这篇文章：https://msdn.microsoft.com/zh-cn/library/hh228607(v=vs.110).aspx

 七、取消任务

var tokenSource2 = new CancellationTokenSource();
            CancellationToken ct = tokenSource2.Token;

            var task = Task.Factory.StartNew(() =>
            {

                // Were we already canceled?
                ct.ThrowIfCancellationRequested();

                bool moreToDo = true;
                while (moreToDo)
                {
                    // Poll on this property if you have to do
                    // other cleanup before throwing.
                    if (ct.IsCancellationRequested)
                    {
                        // Clean up here, then...
                        ct.ThrowIfCancellationRequested();
                    }

                }
            }, tokenSource2.Token); // Pass same token to StartNew.

            tokenSource2.Cancel();

            // Just continue on this thread, or Wait/WaitAll with try-catch:
            try
            {
                task.Wait();
            }
            catch (AggregateException e)
            {
                foreach (var v in e.InnerExceptions)
                    Console.WriteLine(e.Message + " " + v.Message);
            }
            finally
            {
                tokenSource2.Dispose();
            }

            Console.ReadKey();

八、注意点

1、闭包问题，仅捕获最终值，而不是它每次迭代后更改的值；

 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);
            Console.ReadKey();

 // The example displays output like the following:
            //Task #10 created at 636490370838847160 on thread #6.
            //Task #10 created at 636490370838857162 on thread #11.
            //Task #10 created at 636490370838857162 on thread #12.
            //Task #10 created at 636490370838857162 on thread #13.
            //Task #10 created at 636490370838867161 on thread #6.
            //Task #10 created at 636490370838957229 on thread #6.
            //Task #10 created at 636490370838957229 on thread #6.
            //Task #10 created at 636490370838957229 on thread #13.
            //Task #10 created at 636490370838947222 on thread #11.
            //Task #10 created at 636490370838947222 on thread #12

解决方案：通过使用构造函数向任务提供状态对象，可以在每次迭代时访问该值；不要引用外面的循环变量，应该使用传进去的

   // 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);
            Console.ReadKey();

2、AsyncState  此状态作为参数传递给任务委托，并且可通过使用 Task.AsyncState 属性从任务对象访问。简单的说就是开始任务时传了委托的值，这个值可以在任务处理

   修改后可通过AsyncState 对象获取；对上例做下修改：

  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);
                }

            }
            Console.ReadKey();