第七节：利用CancellationTokenSource实现任务取消和利用CancellationToken类检测取消异常。

一. 传统的线程取消

　　所谓的线程取消，就是线程正在执行的过程中取消线程任务。

　　传统的线程取消，是通过一个变量来控制，但是这种方式，在release模式下，被优化从cpu高速缓存中读取，而不是从内存中读取，会造成主线程无法执行这一个bug。

   {
                 var isStop = false;
                 var thread = new Thread(() =>
                 {
                     while (!isStop)
                     {
                         Thread.Sleep();
                         Console.WriteLine("当前thread={0} 正在运行", Thread.CurrentThread.ManagedThreadId);
                     }
                 });
                 thread.Start();
                 Thread.Sleep();
                 isStop = true;
 }

PS： 通过上面的代码看可以看出来，传统模式的线程取消，在排除release模式bug的情况下，局限性还是很明显的。比如：当子线程任务取消的那一刻，我想执行另外一项任务；我想延时取消一个线程任务；线程取消的时候抛异常。

　　上述这几种情况，我们都要借助单独的类来处理。

二. CancellationTokenSource实现任务取消

1. 取消任务的同时触发一个函数

　　利用Cancel方法、Register注册、source.Token标记取消位来实现。

            {
                CancellationTokenSource source = new CancellationTokenSource();
                //注册一个线程取消后执行的逻辑
                source.Token.Register(() =>
                {
                    //这里执行线程被取消后的业务逻辑.
                    Console.WriteLine("-------------我是线程被取消后的业务逻辑---------------------");
                });

                Task.Run(() =>
                {
                    while (!source.IsCancellationRequested)
                    {
                        Thread.Sleep();
                        Console.WriteLine("当前thread={0} 正在运行", Thread.CurrentThread.ManagedThreadId);
                    }
                }, source.Token);

                Thread.Sleep();
                source.Cancel();
            }

2. 延时取消

线程的延时取消有两种方式：

　　方案一：CancelAfter方法。

         #region 方案一：CancelAfter方法
                 {
                     CancellationTokenSource source = new CancellationTokenSource();
                     //注册一个线程取消后执行的逻辑
                     source.Token.Register(() =>
                     {
                         //这里执行线程被取消后的业务逻辑.
                         Console.WriteLine("-------------我是线程被取消后的业务逻辑---------------------");
                     });

                     Task.Run(() =>
                     {
                         while (!source.IsCancellationRequested)
                         {
                             Thread.Sleep();
                             Console.WriteLine("当前thread={0} 正在运行", Thread.CurrentThread.ManagedThreadId);
                         }
                     }, source.Token);

                     Thread.Sleep();
                     //4s后自动取消
                     source.CancelAfter(new TimeSpan(, , , ));
                 }
                 #endregion

　　方案二：CancellationTokenSource构造函数（不再需要Cancel方法了）。

                 {
                     //4s后自动取消
                     CancellationTokenSource source = new CancellationTokenSource();
                     //注册一个线程取消后执行的逻辑
                     source.Token.Register(() =>
                     {
                         //这里执行线程被取消后的业务逻辑.
                         Console.WriteLine("-------------我是线程被取消后的业务逻辑---------------------");
                     });

                     Task.Run(() =>
                     {
                         while (!source.IsCancellationRequested)
                         {
                             Thread.Sleep();
                             Console.WriteLine("当前thread={0} 正在运行", Thread.CurrentThread.ManagedThreadId);
                         }
                     }, source.Token);

                     Thread.Sleep();
                 } 

3. 组合取消

　　 利用CreateLinkedTokenSource构建CancellationTokenSource的组合体，其中任何一个体取消，则组合体就取消。

            {
                CancellationTokenSource source1 = new CancellationTokenSource();

                //source1.Cancel();
                CancellationTokenSource source2 = new CancellationTokenSource();

                source2.Cancel();

                var combineSource = CancellationTokenSource.CreateLinkedTokenSource(source1.Token, source2.Token);

                Console.WriteLine("s1={0}  s2={1}  s3={2}", source1.IsCancellationRequested,
                                                         source2.IsCancellationRequested,
                                                         combineSource.IsCancellationRequested);
            }

　　上述代码，source1和source2中的任何一个取消，combineSource就会被取消。

三. CancellationToken类监控取消

　　CancellationToken类下ThrowIfCancellationRequested属性，等价于if (XXX.IsCancellationRequested){throw new Exception("报错了");}

　　只要取消就报错。

             {
                 CancellationTokenSource source1 = new CancellationTokenSource();
                 CancellationTokenSource source2 = new CancellationTokenSource();
                 var combineSource = CancellationTokenSource.CreateLinkedTokenSource(source1.Token, source2.Token);
                 source1.Cancel();

                 //if (combineSource.IsCancellationRequested)
                 //{
                 //    throw new Exception("报错了");
                 //}

                 //等价于上面那句话
                 try
                 {
                     combineSource.Token.ThrowIfCancellationRequested();
                 }
                 catch (Exception)
                 {
                     Console.WriteLine("报错了");
                 }

                 Console.WriteLine("s1={0}  s2={1}  s3={2}", source1.IsCancellationRequested,
                                                          source2.IsCancellationRequested,
                                                          combineSource.IsCancellationRequested);
             }