Task 使用 Task以及Task.Factory都是在.Net 4引用的。Task跟Thread很类似，通过下面例子可以看到。

1. static public void ThreadMain()
2. {
3. Thread t1 = new Thread(TaskWorker);
4. t1.Start(3);
5. }
6. static public void TaskMain()
7. {
8. Task t1 = new Task(TaskWorker, 3, TaskCreationOptions.PreferFairness | TaskCreationOptions.LongRunning | TaskCreationOptions.AttachedToParent);
9. Console.WriteLine(t1.Status);
10. t1.Start();
11. t1.Wait(); // need to wait for finishing.
12. }
13. static public void TaskWorker(object state)
14. {
15. int nTime = (int)state;
16. for (int i = 0; i < nTime; i++)
17. {
18. Thread.Sleep(100);
19. Console.WriteLine(string.Format("current thread {0} sleep for {1} miniseconds .", Task.CurrentId, (i + 1) * 100));
20. }
21. return;
22. }

我们看到TaskWorker都是用于Task以及Thread，都是只能接受一个参数（Action<object>），不过task可以支持工作函数具有返回值（Func<TRessult>()或者Func<object, TResult>）。但是弱的类型输入跟thread一样。Task提供返回值是为了后面说到的task结构层次有用。

下面是调用一个具有返回值的工作函数

1. static public int TaskWorkerWithReturn(object state)
2. {
3. int nTime = (int)state;
4. for (int i = 0; i < nTime; i++)
5. {
6. Thread.Sleep(100);
7. Console.WriteLine(string.Format("current thread {0} sleep for {1} miniseconds .", Task.CurrentId, (i + 1) * 100));
8. }
9. nTime++;
10. return nTime;
11. }

主调函数为：

1. Task<int> t2 = new Task<int>(TaskWorkerWithReturn, 3, TaskCreationOptions.PreferFairness | TaskCreationOptions.LongRunning | TaskCreationOptions.AttachedToParent);
2. t2.Start();
3. t2.Wait();
4. Console.WriteLine(t2.Result);

不管从工作函数是否有返回值，task都需要在其运行过程中至少有一个前台线程在跑，否则会直接退出，根本原因是所有task都是后台线程。task的工作函数的输入参数类型职能是object。

同步

对于没有返回值的工作函数需要通过内核对象来同步主调线程（例如task内置的事件，使用wait来阻塞等待）；

对于有返回值的工作函数可以通过访问其Result函数来实现阻塞等待。

1. static public int TaskWorkerWithReturn(object state)
2. {
3. int nTime = (int)state;
4. for (int i = 0; i < nTime; i++)
5. {
6. Thread.Sleep(100);
7. Console.WriteLine(string.Format("current thread {0} sleep for {1} miniseconds .", Task.CurrentId, (i + 1) * 100));
8. }
9. nTime++;
10. return nTime;
11. }

主调函数：

1. Task<int> t2 = new Task<int>(TaskWorkerWithReturn, 3, TaskCreationOptions.PreferFairness | TaskCreationOptions.LongRunning | TaskCreationOptions.AttachedToParent);
2. t2.Start();
3. Console.WriteLine("t2:" + t2.Result);

异步调用

作为新的一个特性在.net 4中引入，task能实现丰富的异步调用，使用成员函数ContinueWith来响应异步工作函数的完成，注意，不一定由之前完成异步函数的线程执行。

1. static public void TaskMain()
2. {
3. Task<int> t3 = new Task<int>(FirstTask, 1);
4. t3.Start();
5. Task<int> t4 = t3.ContinueWith<int>(RecusiveTask);
6. Task<int> t5 = t4.ContinueWith<int>(RecusiveTask);
7. Task<int> t6 = t5.ContinueWith<int>(RecusiveTask).ContinueWith<int>(RecusiveTask);
8. //Console.WriteLine(string.Format("final result: {0}", t6.Result));
9. }
10. static public int FirstTask(object state)
11. {
12. int data = (int)state;
13. for (int i = 0; i < data; i++)
14. {
15. Thread.Sleep(100);
16. Console.WriteLine(string.Format("current thread {0} slept for {1} milisecond.", Task.CurrentId, (i + 1) * 100));
17. }
18. data++;
19. return data;
20. }
21. static public int RecusiveTask(Task<int> T)
22. {
23. int data = T.Result;
24. for (int i = 0; i < data; i++)
25. {
26. Thread.Sleep(100);
27. Console.WriteLine(string.Format("current thread {0} slept for {1} milisecond.", Task.CurrentId, (i + 1) * 100));
28. }
29. data++;
30. return data;
31. }

输出结果为：

1. current thread 1 slept for 100 milisecond.
2. current thread 2 slept for 100 milisecond.
3. current thread 2 slept for 200 milisecond.
4. current thread 3 slept for 100 milisecond.
5. current thread 3 slept for 200 milisecond.
6. current thread 3 slept for 300 milisecond.
7. current thread 4 slept for 100 milisecond.
8. current thread 4 slept for 200 milisecond.
9. current thread 4 slept for 300 milisecond.
10. current thread 4 slept for 400 milisecond.
11. current thread 5 slept for 100 milisecond.
12. current thread 5 slept for 200 milisecond.
13. current thread 5 slept for 300 milisecond.
14. current thread 5 slept for 400 milisecond.
15. current thread 5 slept for 500 milisecond.
16. final result: 6
17. 请按任意键继续. . .