C#当中的多线程_任务并行库(中)

发现自己有点懒了！也可能是越往后越难了，看书理解起来有点费劲，所以这两天就每天更新一点学习笔记吧。

4.5 将APM模式转化为任务

 书上提供的三种方式

 方式一：

1  class Program
2         {
3                 //定义一个委托
4                 private delegate string AsynchronousTask(string threadName);
5 
6                 static void Main(string[] args)
7                 {
8                         //实例化一个委托对象，绑定Test函数
9                         AsynchronousTask d = Test;
10 
11                       Console.WriteLine("Option 1");
12                       //调用TaskFactory<TResult> Factory.FromAsync()方法，这个方法有很多重载函数
13                       //这个方法是 public Task<TResult> FromAsync(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod);
14                       Task<string> task = Task<string>.Factory.FromAsync(
15                       d.BeginInvoke("AsyncTaskThread", Callback, "a delegate asynchronous call"), d.EndInvoke);
16                       //绑定任务执行完的后续操作
17                       task.ContinueWith(t => Console.WriteLine("Callback is finished, now running a continuation! Result: {0}",
18                                 t.Result));
19 
20                         //循环打印状态信息
21                         while (!task.IsCompleted)
22                         {
23                                 Console.WriteLine(task.Status);
24                                 Thread.Sleep(TimeSpan.FromSeconds(0.5));
25                         }
26                         Console.WriteLine(task.Status);
27                         Thread.Sleep(TimeSpan.FromSeconds(1));
28 
29                         Console.WriteLine("----------------------------------------------");
30                         Console.WriteLine();
31                 }
32 
33                 //定义一个回调函数
34                 private static void Callback(IAsyncResult ar)
35                 {
36                         Console.WriteLine("Starting a callback...");
37                         Console.WriteLine("State passed to a callbak: {0}", ar.AsyncState);
38                         Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
39                         Console.WriteLine("Thread pool worker thread id: {0}", Thread.CurrentThread.ManagedThreadId);
40                 }
41 
42                 //定义一个委托函数
43                 private static string Test(string threadName)
44                 {
45                         Console.WriteLine("Starting...");
46                         Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
47                         Thread.Sleep(TimeSpan.FromSeconds(2));
48                         Thread.CurrentThread.Name = threadName;
49                         return string.Format("Thread name: {0}", Thread.CurrentThread.Name);
50                 }

方式二：

与方式一差不多，但是使用了TaskFactory<TResult> Factory.FromAsync()方法的另一种重载，该重载并不允许指定一个将会在异步委托调用后被调用的回调函数。但是可以使用后续操作替代它。如果回调函数非常重要，建议使用第一种。

 

1  class Program
2         {
3                 //定义一个委托
4                 private delegate string AsynchronousTask(string threadName);
5 
6                 static void Main(string[] args)
7                 {
8                          //实例化一个委托对象，绑定Test函数
9                          AsynchronousTask d = Test;
10 
11                        Console.WriteLine("Option 2");
12                        //调用TaskFactory<TResult> Factory.FromAsync()方法，这个方法有很多重载函数
13                        /*
14                         * 这个方法重载是 
15                         * public Task<TResult> FromAsync<TArg1>(Func<TArg1, AsyncCallback, object, IAsyncResult> beginMethod, 
16                         * Func<IAsyncResult, TResult> endMethod, 
17                         * TArg1 arg1, 
18                         * object state);
19                         */
20                       Task<string> task= Task<string>.Factory.FromAsync(d.BeginInvoke,d.EndInvoke,
21                                                                                                     "AsyncTaskThread", 
22                                                                                                     "a delegate asynchronous call");
23                                 
24                         //绑定任务执行完的后续操作
25                       task.ContinueWith(t => Console.WriteLine("Task is completed, now running a continuation! Result: {0}",
26                               t.Result));
27 
28                         //循环打印状态信息
29                         while (!task.IsCompleted)
30                         {
31                                 Console.WriteLine(task.Status);
32                                 Thread.Sleep(TimeSpan.FromSeconds(0.5));
33                         }
34                         Console.WriteLine(task.Status);
35                         Thread.Sleep(TimeSpan.FromSeconds(1));
36 
37                         Console.WriteLine("----------------------------------------------");
38                         Console.WriteLine();
39                 }
40 
41                 //定义一个委托函数
42                 private static string Test(string threadName)
43                 {
44                         Console.WriteLine("Starting...");
45                         Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
46                         Thread.Sleep(TimeSpan.FromSeconds(2));
47                         Thread.CurrentThread.Name = threadName;
48                         return string.Format("Thread name: {0}", Thread.CurrentThread.Name);
49                 }

方式三：

1  class Program
2         {
3                 private delegate string IncompatibleAsynchronousTask(out int threadId);
4 
5                 static void Main(string[] args)
6                 {
7                         int threadId;
8                         IncompatibleAsynchronousTask e = Test;
9 
10                         Console.WriteLine("Option 3");
11                         
12                         IAsyncResult ar = e.BeginInvoke(out threadId, Callback, "a delegate asynchronous call");
13 
14                         /*这是一个小技巧，EndMethod使用了out参数，与FromAsync的方法重载并不兼容。
15                          * 然而，可以很轻松地将EndMethod调用封装到一个lambda表达式当中，从而适合
16                          * 工厂方法。
17                          */
18                         Task<string> task = Task<string>.Factory.FromAsync(ar, _ => e.EndInvoke(out threadId, ar));
19                         task.ContinueWith(t =>
20                                 Console.WriteLine("Task is completed, now running a continuation! Result: {0}, ThreadId: {1}",
21                                         t.Result, threadId));
22 
23                         while (!task.IsCompleted)
24                         {
25                                 Console.WriteLine(task.Status);
26                                 Thread.Sleep(TimeSpan.FromSeconds(0.5));
27                         }
28                         Console.WriteLine(task.Status);
29 
30                         Thread.Sleep(TimeSpan.FromSeconds(1));
31                 }
32 
33                 private static void Callback(IAsyncResult ar)
34                 {
35                         Console.WriteLine("Starting a callback...");
36                         Console.WriteLine("State passed to a callbak: {0}", ar.AsyncState);
37                         Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
38                         Console.WriteLine("Thread pool worker thread id: {0}", Thread.CurrentThread.ManagedThreadId);
39                 }
40 
41                 private static string Test(out int threadId)
42                 {
43                         Console.WriteLine("Starting...");
44                         Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
45                         Thread.Sleep(TimeSpan.FromSeconds(2));
46                         threadId = Thread.CurrentThread.ManagedThreadId;
47                         return string.Format("Thread pool worker thread id was: {0}", threadId);
48                 }
49  

总结：感觉这个在日常工作当中使用的真的不是很多，比较晦涩难懂，暂且记住有TaskFactory<TResult> Factory.FromAsync()这个方法，通过这个方法可以将APM转化成TPL

4.6 将EAP模式转换成任务

例子先上：

1 class Program
2     {
3         static void Main(string[] args)
4         {
5             //实例化一个TaskCompletionSource<TResult>，它是实现EAP转化成TPL的关键
6             var tcs = new TaskCompletionSource<int>();
7 
8             var worker = new BackgroundWorker();
9             worker.DoWork += (sender, eventArgs) =>
10             {
11                 eventArgs.Result = TaskMethod("Background worker", 5);
12             };
13 
14             worker.RunWorkerCompleted += (sender, eventArgs) =>
15             {
16                  //如果有错就抛出异常
17                 if (eventArgs.Error != null)
18                 {
19                     tcs.SetException(eventArgs.Error);
20                 }
21                  //如果是取消操作，就取消操作
22                 else if (eventArgs.Cancelled)
23                 {
24                     tcs.SetCanceled();
25                 }
26                 else
27                 {
28                     //正常情况返回结果
29                     tcs.SetResult((int)eventArgs.Result);
30                 }
31             };
32 
33             //运行任务
34             worker.RunWorkerAsync();
35 
36             //获取结果
37             int result = tcs.Task.Result;
38 
39             Console.WriteLine("Result is: {0}", result);
40         }
41 
42         static int TaskMethod(string name, int seconds)
43         {
44             Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
45                 name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
46             Thread.Sleep(TimeSpan.FromSeconds(seconds));
47             return 42 * seconds;
48         }

4.7 实现取消选项

我们在前面说过线程工作的取消需要依靠两个类来实现，分别是CancellationTokenSource和CancellationToken这两个类

1     class Program
2     {
3         private static void Main(string[] args)
4         {
5               //定义一个CancellationTokenSource类
6               var cts = new CancellationTokenSource();
7               //创建第一个任务，这里有个很奇怪的第地方，cts.Token被传了两次
8               //分别传给了TaskMethod方法个Task的构造函数，为什么这么做呢？
9               var longTask = new Task<int>(() => TaskMethod("Task 1", 10, cts.Token), cts.Token);
10             //打印任务状态
11             Console.WriteLine(longTask.Status);
12             //取消任务
13             cts.Cancel();
14             //再次打印任务状态
15             Console.WriteLine(longTask.Status);
16             Console.WriteLine("First task has been cancelled before execution");
17 
18             //创建第二个任务
19             cts = new CancellationTokenSource();
20             longTask = new Task<int>(() => TaskMethod("Task 2", 10, cts.Token), cts.Token);
21             //启动任务
22             longTask.Start();
23             for (int i = 0; i < 5; i++ )
24             {
25                 Thread.Sleep(TimeSpan.FromSeconds(0.5));
26                 Console.WriteLine(longTask.Status);
27             }
28             //取消任务
29             cts.Cancel();
30             //打印任务状态
31             for (int i = 0; i < 5; i++)
32             {
33                 Thread.Sleep(TimeSpan.FromSeconds(0.5));
34                 Console.WriteLine(longTask.Status);
35             }
36 
37             Console.WriteLine("A task has been completed with result {0}.", longTask.Result);
38         }
39 
40         private static int TaskMethod(string name, int seconds, CancellationToken token)
41         {
42             Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
43                 name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
44             for (int i = 0; i < seconds; i ++)
45             {
46                 Thread.Sleep(TimeSpan.FromSeconds(1));
47                 //如果任务被取消，就返回-1
48                 if (token.IsCancellationRequested) return -1;
49             }
50             return 42*seconds;
51          }
52    }

cts.Token被传了两次为什么呢？如果在任务实际启动前取消它，该任务的TPL基础设施有责任处理该取消操作，因为这些代码根本不会被执行，通过得到第一个任务的状态可以知道它被取消了。如果尝试对该任务调用Start方法，将会得到InvalidOperationException异常。

 

解释：

如果在Task构造函数当中取消了，cts.Token这个参数，那么在Cts.Cancel()后面执行longTask.Start(); 会出现什么情况呢？

如下图所示，任务只有在运行操作的时候才能检查到取消操作。所以才会有WaitingToRun这个状态出现。

如果添加了这个参数，结果如下：

这个时候，在取消操作执行完后，执行开始操作就会抛出异常。