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

一. 传统的线程取消

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

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

  {
                var isStop = false;
                var thread = new Thread(() =>
                {
                    while (!isStop)
                    {
                        Thread.Sleep(100);
                        Console.WriteLine("当前thread={0} 正在运行", Thread.CurrentThread.ManagedThreadId);
                    }
                });
                thread.Start();
                Thread.Sleep(1000);
                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(100);
                        Console.WriteLine("当前thread={0} 正在运行", Thread.CurrentThread.ManagedThreadId);
                    }
                }, source.Token);

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

2. 延时取消

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

　　方案一：CancelAfter方法。

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

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

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

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

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

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

                    Thread.Sleep(2000);
                } 

 

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);
            }