说起多线程，想到更多的是线程Thread,那么我们今天说的任务Task和线程有什么关系呢？
- 任务是架构在线程之上的，也就是说任务最终还是要抛给线程去执行；
- 线程和任务并不是一对一的关系，比如开10个任务并不是说就会开10个线程，这一点任务和线程池有点类似，但是任务相比线程池开销更小控制也更为精确；
关于Task
Task标识一个异步操作，创建Task有两种方法，一种类似于创建对象直接new出来，一种是通过工厂创建。
public void CreateTask()
{
//直接实例化
var task1 = new Task(() =>
{
Console.WriteLine("任务1创建成功!");
});
task1.Start();
//通过静态工厂创建
var task2 = Task.Factory.StartNew(() => {
Console.WriteLine("任务2创建成功!");
});
}
下面来看一下一个Task的生命周期，编写测试代码：
public void GetTaskStatus()
{
//直接实例化
var task1 = new Task(() =>
{
Console.WriteLine("开始");
Thread.Sleep(10000);
Console.WriteLine("结束");
});
Console.WriteLine(task1.Status);
task1.Start();
Console.WriteLine(task1.Status);
task1.Wait();
Console.WriteLine(task1.Status);
}
运行结果：
由此可见 一个Task的生命周期中至少包含以下三个阶段：
- Created: Task被创建
- WaitingToRun :等待执行
- RanToCompletion: 任务执行完成
其实至少应该还包含一个阶段：Running表示运行中。
下面谈谈Task的任务控制，这也是Task的优势所在，可以使以前无法控制的并行过程按照自己的需求变得有序可控起来。
Task.Wait
上面的示例中已经用过了，就是等待任务执行完成，阻塞主线程，多用于线程(任务)与主线程同步。
Task.WaitAll
顾名思义，多个任务并行执行时，等待所有任务执行完成，实例代码：
public void WaitAllTask()
{
var task1 = new Task(() =>
{
Console.WriteLine("任务一开始!");
Thread.Sleep(2000);
Console.WriteLine("任务一结束!");
});
var task2 = new Task(() =>
{
Console.WriteLine("任务二开始!");
Thread.Sleep(2000);
Console.WriteLine("任务二结束!");
});
task1.Start();
task2.Start();
Task.WaitAll(task1,task2);
Console.WriteLine("所有任务执行完成!");
}
执行结果：
可见等到两个任务全部结束后，主线程才提示任务结束。
Task.WaitAny
等待任意一个任务执行结束，上面的示例代码修改下：
task1.Start();
task2.Start();
Task.WaitAny(task1, task2);
Console.WriteLine("有任务执行完成!");
执行结果：
可见任务一结束后主线程就提示有任务完成了。
Task.ContinueWith
一个Task任务后自动开启另一个Task，实现Task的延续。实例代码如下：
public void TaskContinue()
{
var task1 = new Task(() =>
{
Console.WriteLine("任务一开始!");
Thread.Sleep(2000);
Console.WriteLine("任务一结束!");
});
var task2 = new Task(() =>
{
Console.WriteLine("任务二开始!");
Thread.Sleep(20000);
Console.WriteLine("任务二结束!");
});
task1.Start();
task2.Start();
var result = task1.ContinueWith(task =>
{
Console.WriteLine("任务一完成");
return String.Format("任务一结束后状态{0}",task.Status);
});
Console.WriteLine(result.Result.ToString());
}
运行结果：
Task的取消
前面说了那么多Task的用法，下面我们来看Task的取消，比如我们启动了一个Task,出现了遗产或者用户主动选择取消，我们是可以取消这个任务的。在任务Task中，我们通过calcellation的tokens来取消一个Task,有些时候在Task的Body里面会包含循环，我们可以在轮询的时候判断IscancellationRequested的属性是否为True,如果为True的时候就return或者抛出异常。下面在代码中我们看下如何实现任务的取消：
public void TaskCancel()
{
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
var task = Task.Factory.StartNew(() => {
Int32 sec = 0;
while (true)
{
if (token.IsCancellationRequested)
{
Console.WriteLine("任务被终止，即将退出");
break;
}
else
{
Console.WriteLine("计时{0}s", sec);
}
Thread.Sleep(1000);
sec += 1;
}
},token);
token.Register(() => {
Console.WriteLine("任务取消");
});
Console.WriteLine("按任意键退出计时");
Console.ReadKey();
tokenSource.Cancel();
}
这里开启了一个Task，并给token注册了一个方法，输出信息，然后等待用户输入，用户输入任意信息后，执行tokenSource.Cancel方法，任务随即被取消，执行结果如下：
Task的嵌套
Task中还可以再嵌套Task，Task中的嵌套可以分为两种。关联嵌套和非关联嵌套，也就是说内层的Task和外层的Task是否有关联，下面我们代码示例来说明：
public void TaskWithTask()
{
var pTask = Task.Factory.StartNew(() => {
var cTask = Task.Factory.StartNew(() => {
Thread.Sleep(1000);
Console.WriteLine("子任务完成");
});
Console.WriteLine("父任务完成");
});
pTask.Wait();
Console.WriteLine("非关联嵌套");
}
运行结果：
由执行结果可知，外层的pTask运行完成后，并不会等待内层的cTask,直接向下走了，其实这种嵌套相当于我们创建了两个Task,只是写到一起，代码可读性更强，并且可以在一个Task中加入多个Task,让进度并行前进。
再看一个实例：
public void TaskWithTask()
{
var pTask = Task.Factory.StartNew(() =>
{
var cTask = Task.Factory.StartNew(() =>
{
Thread.Sleep(1000);
Console.WriteLine("子任务完成");
},TaskCreationOptions.AttachedToParent);
Console.WriteLine("父任务完成");
});
pTask.Wait();
Console.WriteLine("非关联嵌套");
}
我们在创建cTask的时候，加入了参数TaskCreationOptions.AttachedToParent，这个时候pTask和cTask就产生了关联，cTask就会成为pTask的一部分，执行结果：
可见tTask会等待cTask执行完成。
下面我们来看一个task综合使用的例子，看一些多任务是如何协作的，假设这样一个场景：任务2和任务3要等待任务1完成后，取得任务1的结果，然后开始执行。任务4要等待任务2完成，取得其结果才能执行，最终任务3和任务4都完成了，合并结果，任务完成。
代码如下：
public void MutiTasks()
{
var t1 = Task.Factory.StartNew<Int32>(() => {
Console.WriteLine("任务一执行");
return 1;
});
t1.Wait();
var t3 = Task.Factory.StartNew<Int32>(() => {
Console.WriteLine("任务三执行");
return t1.Result+3;
});
var t4 = Task.Factory.StartNew<Int32>(() =>
{
Console.WriteLine("任务二执行");
return t1.Result + 2;
}).ContinueWith<Int32>(task => {
Console.WriteLine("任务四执行");
return task.Result + 4;
});
Task.WaitAll(t3,t4);
Console.WriteLine(t3.Result + t4.Result);
}
运行结果：
Task的异常处理
任何应用程序都需要异常处理机制，谁也无法保证自己写得代码在任何时候都是可以正常运行的，那么在Task中到底该怎么处理异常呢?我们先尝试一下用try-catch
public void TaskExcetion()
{
try
{
var pTask = Task.Factory.StartNew(() =>
{
var cTask = Task.Factory.StartNew(() =>
{
Thread.Sleep(1000);
throw new Exception("子任务异常");
Console.WriteLine("子任务完成");
});
throw new Exception("父任务异常");
Console.WriteLine("父任务完成");
});
pTask.Wait();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("非关联嵌套");
}
看一下结果：
可见异常信息并不对，其实正确的姿势是这个样子的：
public void TaskAggregateExcetion()
{
try
{
var pTask = Task.Factory.StartNew(() =>
{
var cTask = Task.Factory.StartNew(() =>
{
Thread.Sleep(1000);
throw new Exception("子任务异常");
Console.WriteLine("子任务完成");
});
throw new Exception("父任务异常");
Console.WriteLine("父任务完成");
});
pTask.Wait();
}
catch (AggregateException ex)
{
foreach (Exception item in ex.InnerExceptions)
{
Console.WriteLine(item.Message);
}
}
Console.WriteLine("非关联嵌套");
}
运行结果：
这里用了AggregateException，就是异常集合，当然开发中不会只有一个线程，肯定会有多个线程，多个线程就可能有多个异常。当然，除了在task中使用异常，我们还可以通过Task的几个属性来判断Task的状态，如：IsCompleted, IsFaulted, IsCancelled,Exception等等来判断task是否成功的执行了。