多线程(4)Task

　　使用线程池使得创建线程已经很简单了，但是使用线程池不支持线程的取消，完成和失败通知等交互操作，为了解决这些问题，.net 4.0带来了TPL(Task Parallel Library)任务并行库，下面就来总结下Task的使用。

创建和运行任务

在.net 4.0下使用task创建一个线程非常简单，有两种方式，如下代码：

 namespace ConsoleApplication19
 {
     class Program
     {
         static void Main(string[] args)
         {
             //方法1
             var task1 = new Task(() =>
             {
                 Console.WriteLine("Create and start task!");
             });
             task1.Start();

             //方法2
             Task.Factory.StartNew(() =>
             {
                 Console.WriteLine("Task factory start new task!");
             });

             Console.ReadKey();
         }
     }
 }

输出结果：

需要注意的是：task也是基于线程池的，所以这两个任务的执行顺序是不固定的。

取消任务

创建一个新的任务之后，我们随时都可以取消它，取消方法如下代码：

 namespace ConsoleApplication20
 {
     class Program
     {
         static void Main(string[] args)
         {
             Console.WriteLine("Main thread starting...");

             var cts = new CancellationTokenSource();
             var task1 = Task.Factory.StartNew(() =>
             {
                 TaskAction(cts.Token);
             });

             Thread.Sleep();
             Console.WriteLine(string.Format("current task status:：{0}", task1.Status));

             //取消任务
             cts.Cancel();
             Console.WriteLine("start cancel task!");
             for (int i = ; i < ; i++)
             {
                 Thread.Sleep();
                 Console.WriteLine(string.Format("current task status:：{0}", task1.Status));
             }

             Console.WriteLine("Main thread completed!");
             Console.ReadKey();
         }

         public static void TaskAction(CancellationToken token)
         {
             Console.WriteLine("Sub thread starting...");

             while (true)
             {
                 Thread.Sleep();
                 if (token.IsCancellationRequested)
                 {
                     Console.WriteLine("Sub thread be cancelled!");
                     return;
                 }
                 Console.WriteLine("Sub thread is running!");
             }
         }

     }
 }

输出结果：

创建任务集合并输出结果

如下代码：

 namespace ConsoleApplication21
 {
     class Program
     {
         static void Main(string[] args)
         {
             //创建任务集合并输出结果
             var tasks = new List<Task<string>>();

             var task1 = Task.Factory.StartNew<string>(() =>
             {
                 Console.WriteLine("task1 running on thread id:"+ Thread.CurrentThread.ManagedThreadId);
                 return "task1";
             });
             tasks.Add(task1);

             var task2 = Task.Factory.StartNew<string>(() =>
             {
                 Console.WriteLine("task2 running on thread id:" + Thread.CurrentThread.ManagedThreadId);
                 return "task2";
             });
             tasks.Add(task2);

             var task3 = Task.Factory.StartNew<string>(() =>
             {
                 Console.WriteLine("task3 running on thread id:" + Thread.CurrentThread.ManagedThreadId);
                 return "task3";
             });
             tasks.Add(task3);

             //输出结果
             foreach (var item in tasks)
             {
                 Console.WriteLine(item.Result);//调用Task的Result方法相当于调用了Task.WaitAll(tasks.ToArray());
             }

             Console.ReadKey();
         }
     }
 }

输出结果：

这里要注意2点：

1，每个任务会开启一个新的线程，并且运行顺序不固定。

2，Task.Result相当于调用了Wait方法，等待异步任务完成。

多任务的串行化

如下代码：

 namespace ConsoleApplication22
 {
     class Program
     {
         static void Main(string[] args)
         {
             //多任务的串行化
             var task1 = Task.Factory.StartNew(() =>
             {
                 Console.WriteLine("start task1...");
                 Console.WriteLine("current thread id:"+ Thread.CurrentThread.ManagedThreadId);
             });

             var task2 = task1.ContinueWith((item) =>
             {
                 Console.WriteLine("start task2...");
                 Console.WriteLine("current thread id:" + Thread.CurrentThread.ManagedThreadId);
             });

             var task3 = task2.ContinueWith((item)=>
             {
                 Console.WriteLine("start task3...");
                 Console.WriteLine("current thread id:" + Thread.CurrentThread.ManagedThreadId);
             });

             Console.ReadKey();
         }
     }
 }

输出结果：

注意，多任务串行化后，就相当于顺序执行了，而且有可能使用的是同一个线程，从上图的thread id就可以看出来。

多任务等待执行完成

如下代码：

 namespace ConsoleApplication23
 {
     class Program
     {
         static void Main(string[] args)
         {
             //多任务等待执行完成
             var tasks = new List<Task<string>>();

             var task1 = Task.Factory.StartNew<string>(() =>
             {
                 Console.WriteLine("task1");
                 return "task1";
             });
             tasks.Add(task1);

             var task2 = Task.Factory.StartNew<string>(() =>
             {
                 Console.WriteLine("task2");
                 return "task2";
             });
             tasks.Add(task2);

             var task3 = Task.Factory.StartNew<string>(() =>
             {
                 Console.WriteLine("task3");
                 return "task3";
             });
             tasks.Add(task3);

             //等待所有任务完成
             Task.WaitAll(tasks.ToArray());

             //等价于下面的调用
             //foreach (var item in tasks)
             //{
             //    item.Result
             //}

             Console.ReadKey();
         }
     }
 }

输出结果：

需要注意的是，如果是有返回值的task，可以使用Task.Result获取返回值的同时，也在等待Task执行完成，相当于调用了Task.Wait方法。

创建子任务

如下代码：

 namespace ConsoleApplication24
 {
     class Program
     {
         static void Main(string[] args)
         {
             //创建子任务
             var parentTask = Task.Factory.StartNew(() =>
             {
                 Console.WriteLine("parent task!");
                 var childTask = Task.Factory.StartNew(() =>
                 {
                     Console.WriteLine("child task!");
                 }, TaskCreationOptions.AttachedToParent);
             });

             Console.ReadKey();
         }
     }
 }

输出结果：