TaskAdvanced

多线程中，如果要捕捉异常，需要设置主线程等待子线程执行结束才可以捕捉到异常
多线程内部发生异常后，抛出的异常类型是：system.AggregateException(多线程的异常类型)
如果（try-catch--catch）给定多个异常类型类匹配，多线程中，异常之后，有限配具体，如果没有具体，再匹配抽象

 try
                {
                    List<Task> tasklist = new List<Task>();
                    for (int i = 0; i < 20; i++)
                    {
                        string keywork = $"TsakAdvanced_Click_{i}";
                        tasklist.Add(Task.Run(() =>
                       {
                           Thread.Sleep(new Random().Next(50, 100));
                           if (keywork == "TsakAdvanced_Click_6")
                           {
                               throw new Exception("TsakAdvanced_Click_6");
                           }
                           else if (keywork == "TsakAdvanced_Click_9")
                           {
                               throw new Exception("TsakAdvanced_Click_9");
                           }
                           else if (keywork == "TsakAdvanced_Click_12")
                           {
                               throw new Exception("TsakAdvanced_Click_12");
                           }
                       }));
                    }
                    Task.WaitAll(tasklist.ToArray());

                }
                catch (AggregateException aex) //具体    
                {
                    Debug.WriteLine(aex.Message);   //三个具体的线程异常都可以捕捉到，然后放到集合中
                    foreach (var exception in aex.InnerExceptions)
                    {
                        Console.WriteLine(exception.Message);
                    }
                }
                catch (Exception ex) //父类（一切异常的父类） 抽象
                {
                    Debug.WriteLine(ex.Message);
                }

　线程取消

如果三个线程去执行一个业务逻辑体（查询-- - 线程1--执行修改数据库；线程2-- - 执行修改缓存，线程三--执行一个调用接口去修改另外一个服务器上的数据）
以上这个逻辑体执行过程中，如果有一个线程是异常了；在这个逻辑体中，其实就是一个残缺的--表示整个逻辑就有问题！
多线程执行的时候，有时候，必须是多个线程都执行成功，才算成功，只要有一个线程异常了，就表示都异常----既然都是异常了，就应该让线程取消；已经异常了，就没继续往后的必要了

线程是无法从外部取消的（除非关闭进程）

a） 实例化一个 CancellationTokenSource
b) 包含了一个IsCancellationRequested 属性，属性值默认为false
c) 包含了一个Cancel方法--Cancel 方法如果被执行--CancellationTokenSource 内部的属性值马上-- - false--true; 且只能从 false--true 不能由true--false

线程取消的逻辑

线程取消--看哪个线程跑的慢，如果有一个线程发生了异常了，跑的慢的线程，就会被取消掉（异常掉），如果跑的都比较快的线程--当还没有线程发生异常的时候，这个比较快的线程已经结束了，那么这个结束的线程是无法被取消的;

当有一个线程发生异常的时候，其他线程就会有三种情况 1.已经结束的线程--不管（管不住）； 2.已经正常开始，我可以让你取消，让这线程在结束的时候，抛出异常（取消了）；3.还有部分的线程根本都还没有开启：只要有异常的线程，就应该让没有开启的线程不再开启了

try
            {
                List<Task> tasks = new List<Task>();
                CancellationTokenSource cts = new CancellationTokenSource();
                for (int i = 0; i < 100; i++)
                {
                    string keywork = $"TsakAdvanced_Click_{i}";
                    tasks.Add(Task.Run(() =>
                    {
                        Thread.Sleep(new Random().Next(10, 300));
                        //if (cts.IsCancellationRequested == false)
                        //{
                        //    Debug.WriteLine($" 线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} 正常开始了");
                        //}
                        //else
                        //{
                        //    Debug.WriteLine($" 线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} 没有正常开始了");
                        //    //throw new Exception($"{Thread.CurrentThread.ManagedThreadId.ToString("00") }取消了。。。");
                        //}
                        cts.Token.ThrowIfCancellationRequested();
                        try
                        {
                            if (keywork == "TsakAdvanced_Click_6")
                            {
                                throw new Exception("TsakAdvanced_Click_6");
                            }
                        }
                        catch (Exception)
                        {
                            cts.Cancel();
                        }
                        cts.Token.ThrowIfCancellationRequested();


                        //if (cts.IsCancellationRequested == false)
                        //{
                        //    Debug.WriteLine($" 线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} 正常结束了。。。");
                        //}
                        //else
                        //{ 

                        //    Debug.WriteLine($" 线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} 没有正常结束了。。。");
                        //    //throw new Exception($"{Thread.CurrentThread.ManagedThreadId.ToString("00") }取消了。。。" );
                        //}
                    }, cts.Token)); //有线程发生异常后，还没有开启的线程就不再开启了
                }
                Task.WaitAll(tasks.ToArray());
            }
            catch (AggregateException aex)
            {
                foreach (var exception in aex.InnerExceptions)
                {
                    Debug.WriteLine(exception.Message);
                } 
            } 　

Thread thread = null;
thread.Abort(); //取消线程   thread中的用法