发布：2019/12/17 22:43:46作者：管理员 来源：本站 浏览次数：1021
一、介绍下Task
对于多线程，我们经常使用的是Thread。在我们了解Task之前，如果我们要使用多核的功能可能就会自己来开线程，然而这种线程模型在.net 4.0之后被一种称为基于“任务的编程模型”所冲击，因为task会比thread具有更小的性能开销，不过大家肯定会有疑惑，任务和线程到底有什么区别呢？
任务和线程的区别：
1、任务是架构在线程之上的，也就是说任务最终还是要抛给线程去执行。
2、任务跟线程不是一对一的关系，比如开10个任务并不是说会开10个线程，这一点任务有点类似线程池，但是任务相比线程池有很小的开销和精确的控制。
3、Task的优势
ThreadPool相比Thread来说具备了很多优势，但是ThreadPool却又存在一些使用上的不方便。比如：
◆ ThreadPool不支持线程的取消、完成、失败通知等交互性操作；
◆ ThreadPool不支持线程执行的先后次序；
以往，如果开发者要实现上述功能，需要完成很多额外的工作，现在，微软提供了一个功能更强大的概念：Task。Task在线程池的基础上进行了优化，并提供了更多的API。在Framework 4.0中，如果我们要编写多线程程序，Task显然已经优于传统的方式。
以下是一个简单的任务示例：
using System;
using System.Threading;
using System.Threading.Tasks;
namespace ConsoleApp1
{
class Program
{
static void Main(string[] args)
{
Task t = new Task(() =>
{
Console.WriteLine("任务开始工作……");
//模拟工作过程
Thread.Sleep(5000);
});
t.Start();
t.ContinueWith((task) =>
{
Console.WriteLine("任务完成，完成时候的状态为：");
Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task.IsCanceled, task.IsCompleted, task.IsFaulted);
});
Console.ReadKey();
}
}
}
二、创建Task
创建Task的方法有两种，一种是直接创建——new一个出来，一种是通过工厂创建。下面来看一下这两种创建方法：
//第一种创建方式，直接实例化
Task task1 = new Task(() =>
{
//To Do you code 也可以在这直接调用方法，直接传递参数，也比较方便
});
这是最简单的创建方法，可以看到其构造函数是一个Action，其构造函数有如下几种，比较常用的是前两种。
/第二种创建方式，工厂创建
var task2 = Task.Factory.StartNew(() =>
{
//TODO you code
});
这种方式通过静态工厂，创建一个Task并运行。
构造函数创建的task,必须手动Start,而通过工厂创建的Task直接就启动了。
下面我们来看一下Task的声明周期，编写如下代码：
var task1 = new Task(() =>
{
Console.WriteLine("Begin");
System.Threading.Thread.Sleep(2000);
Console.WriteLine("Finish");
});
Console.WriteLine("Before start:" + task1.Status);
task1.Start();
Console.WriteLine("After start:" + task1.Status);
task1.Wait();
Console.WriteLine("After Finish:" + task1.Status);
Console.Read();
ask1.Status就是输出task的当前状态，其输出结果如下：
在这里插入图片描述
可以看到调用Start前的状态是Created，然后等待分配线程去执行，到最后执行完成。
从我们可以得出Task的简略生命周期：
Created：表示默认初始化任务，但是“工厂创建的”实例直接跳过。
WaitingToRun: 这种状态表示等待任务调度器分配线程给任务执行。
RanToCompletion：任务执行完毕。
三、Task的任务控制
Task最吸引人的地方就是他的任务控制了，你可以很好的控制task的执行顺序，让多个task有序的工作。下面来详细说一下：
1、Task.Wait
在上个例子中，我们已经使用过了，task1.Wait();就是等待任务执行完成，我们可以看到最后task1的状态变为Completed。
2、Task.WaitAll
看字面意思就知道，就是等待所有的任务都执行完成，下面我们来写一段代码演示一下：
static void Main(string[] args)
{
var task1 = new Task(() =>
{
Console.WriteLine("Task 1 Begin");
System.Threading.Thread.Sleep(2000);
Console.WriteLine("Task 1 Finish");
});
var task2 = new Task(() =>
{
Console.WriteLine("Task 2 Begin");
System.Threading.Thread.Sleep(3000);
Console.WriteLine("Task 2 Finish");
});
task1.Start();
task2.Start();
Task.WaitAll(task1, task2);
Console.WriteLine("All task finished!");
Console.Read();
}
其输出结果如下：
在这里插入图片描述
3、Task.WaitAny
这个用发同Task.WaitAll，就是等待任何一个任务完成就继续向下执行，将上面的代码WaitAll替换为WaitAny，输出结果如下：
在这里插入图片描述
4、Task.ContinueWith
就是在第一个Task完成后自动启动下一个Task，实现Task的延续，下面我们来看下他的用法，编写如下代码：
static void Main(string[] args)
{
var task1 = new Task(() =>
{
Console.WriteLine("Task 1 Begin");
System.Threading.Thread.Sleep(2000);
Console.WriteLine("Task 1 Finish");
});
var task2 = new Task(() =>
{
Console.WriteLine("Task 2 Begin");
System.Threading.Thread.Sleep(3000);
Console.WriteLine("Task 2 Finish");
});
task1.Start();
task2.Start();
var result = task1.ContinueWith<string>(task =>
{
Console.WriteLine("task1 finished!");
return "This is task result!";
});
Console.WriteLine(result.Result.ToString());
Console.Read();
}
在这里插入图片描述
可以看到，task1完成之后，开始执行后面的内容，并且这里我们取得task的返回值。
在每次调用ContinueWith方法时，每次会把上次Task的引用传入进来，以便检测上次Task的状态，比如我们可以使用上次Task的Result属性来获取返回值。我们还可以这么写：
Task.Factory.StartNew<string>(() => {return "One";}).ContinueWith(ss => { Console.WriteLine(ss.Result);});
输出One
要写可伸缩的软件，一定不能使你的线程阻塞。这意味着如果调用Wait或者在任务未完成时查询Result属性，极有可能造成线程池创建一个新线程，这增大了资源的消耗，并损害了伸缩性。
注意下面代码中TaskContinuationOptions 枚举，挺有意思的：
static void Main(string[] args)
{
Task<Int32> t = new Task<Int32>(i => Sum((Int32)i),10000);
t.Start();
t.ContinueWith(task=>Console.WriteLine("The sum is:{0}",task.Result),
TaskContinuationOptions.OnlyOnRanToCompletion);
t.ContinueWith(task=>Console.WriteLine("Sum throw:"+task.Exception),
TaskContinuationOptions.OnlyOnFaulted);
t.ContinueWith(task=>Console.WriteLine("Sum was cancel:"+task.IsCanceled),
TaskContinuationOptions.OnlyOnCanceled);
try
{
t.Wait(); // 测试用
}
catch (AggregateException)
{
Console.WriteLine("出错");
}
}
private static Int32 Sum(Int32 i)
{
Int32 sum = 0;
for (; i > 0; i--)
{
checked { sum += i; }
}
return sum;
}
}
AttachedToParnt枚举类型（父任务）也不能放过！看看怎么用，写法有点新奇，看看：
static void Main(string[] args)
{
Task<Int32[]> parent = new Task<Int32[]>(() => {
var results = new Int32[3];
//
new Task(() => results[0] = Sum(10000), TaskCreationOptions.AttachedToParent).Start();
new Task(() => results[1] = Sum(20000), TaskCreationOptions.AttachedToParent).Start();
new Task(() => results[2] = Sum(30000), TaskCreationOptions.AttachedToParent).Start();
return results;
});
var cwt = parent.ContinueWith( parentTask=>Array.ForEach(parentTask.Result,Console.WriteLine));
parent.Start();
cwt.Wait();
}
private static Int32 Sum(Int32 i)
{
Int32 sum = 0;
for (; i > 0; i--)
{
checked { sum += i; }
}
return sum;
}
}
例子中，父任务创建启动3个Task对象。默认情况下，一个任务创建的Task对象是顶级任务，这些任务跟创建它们的那个任务没有关系。
TaskCreationOptions.AttachedToParent标志将一个Task和创建它的那个Task关联起来，除非所有子任务（子任务的子任务）结束运行，否则创建任务（父任务）不会认为已经结束。调用ContinueWith方法创建一个Task时，可以指定TaskContinuationOptions.AttachedToParent标志将延续任务置顶为一个子任务。
在这里插入图片描述
看了这么多任务的方法操作示例了，现在来挖挖任务内部构造：
每个Task对象都有一组构成任务状态的字段。
一个Int32 ID（只读属性）
1.代表Task执行状态的一个Int32
2.对父任务的一个引用
3.对Task创建时置顶TaskSchedule的一个引用
4.对回调方法的一个引用
5.对要传给回调方法的对象的一个引用（通过Task只读AsyncState属性查询）
6.对一个ExceptionContext的引用
7.对一个ManualResetEventSlim对象的引用
8.还有没个Task对象都有对根据需要创建的一些补充状态的一个引用，补充状态包含这些：
(1)一个CancellationToken
(2) 一个ContinueWithTask对象集合
(3)为抛出未处理异常的子任务，所准备的一个Task对象集合
ContinueWith便是一个更好的方式，一个任务完成时它可以启动另一个任务。
更多ContinueWith用法参见：http://technet.microsoft.com/zh-CN/library/dd321405
5、Task的取消和异常处理
前面说了那么多Task的用法，下面来说下Task的取消，比如我们启动了一个task,出现异常或者用户点击取消等等，我们可以取消这个任务
在一个线程调用Wait方法时，系统会检查线程要等待的Task是否已经开始执行，如果任务正在执行，那么这个Wait方法会使线程阻塞，直到Task运行结束为止。
在一个任务抛出一个未处理的异常时，这个异常会被“包含”不并存储到一个集合中，而线程池线程是允许返回到线程池中的，在调用Wait方法或者Result属性时，这个成员会抛出一个System.AggregateException对象。
现在你会问，为什么要调用Wait或者Result？或者一直不查询Task的Exception属性？你的代码就永远注意不到这个异常的发生，如果不能捕捉到这个异常，垃圾回收时，抛出AggregateException，进程就会立即终止，这就是“牵一发动全身”，莫名其妙程序就自己关掉了，谁也不知道这是什么情况。所以，必须调用前面提到的某个成员，确保代码注意到异常，并从异常中恢复。悄悄告诉你，其实在用Result的时候，内部会调用Wait。
怎么恢复？
为了帮助你检测没有注意到的异常，可以向TaskScheduler的静态UnobservedTaskException时间等级一个回调方法，当Task被垃圾回收时，如果出现一个没有被注意到的异常，CLR终结器会引发这个事件。
一旦引发，就会向你的时间处理器方法传递一个UnobservedTaskExceptionEvenArgs对象，其中包含了你没有注意的AggregateException。然后再调用UnobservedTasExceptionEvenArgs的SetObserved方法来指出你的异常已经处理好了，从而阻止CLR终止进程。这是个图省事的做法，要少做这些，宁愿终止进程，也不要呆着已经损坏的状态而继续运行。
除了单个等待任务，Task 还提供了两个静态方法：WaitAny和WaitAll，他们允许线程等待一个Task对象数组。
WaitAny方法会阻塞调用线程，知道数组中的任何一个Task对象完成，这个方法会返回一个索引值，指明完成的是哪一个Task对象。如果发生超时，方法将返回-1。它可以通过一个CancellationToken取消，会抛出一个OperationCanceledException。
WaitAll方法也会阻塞调用线程，知道数组中的所有Task对象都完成，如果全部完成就返回true，如果超时就返回false。当然它也能取消，同样会抛出OperationCanceledException。
说了取消任务的方法，现在来试试这个方法，加深下印象，修改先前例子代码，完整代码如下：
static void Main(string[] args)
{
CancellationTokenSource cts = new CancellationTokenSource();
Task<Int32> t = new Task<Int32>(() => Sum(cts.Token,10000), cts.Token);
//可以现在开始，也可以以后开始
t.Start();
//在之后的某个时间，取消CancellationTokenSource 以取消Task
cts.Cancel();//这是个异步请求，Task可能已经完成了。我是双核机器，Task没有完成过
//注释这个为了测试抛出的异常
//Console.WriteLine("This sum is:" + t.Result);
try
{
//如果任务已经取消了，Result会抛出AggregateException
Console.WriteLine("This sum is:" + t.Result);
}
catch (AggregateException x)
{
//将任何OperationCanceledException对象都视为已处理。
//其他任何异常都造成抛出一个AggregateException，其中
//只包含未处理的异常
x.Handle(e => e is OperationCanceledException);
Console.WriteLine("Sum was Canceled");
}
}
private static Int32 Sum(CancellationToken ct ,Int32 i)
{
Int32 sum = 0;
for (; i > 0; i--)
{
//在取消标志引用的CancellationTokenSource上如果调用
//Cancel，下面这一行就会抛出OperationCanceledException
ct.ThrowIfCancellationRequested();
checked { sum += i; }
}
return sum;
}
}
整理 自：https://www.cnblogs.com/tuyile006/p/7154924.html
https://www.e-learn.cn/content/net/1114080
https://www.cnblogs.com/wangchuang/p/5737188.html
