20181106_线程之异常_取消_变量_安全Lock

Posted wxylog

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了20181106_线程之异常_取消_变量_安全Lock相关的知识,希望对你有一定的参考价值。

一. 线程的异常处理:

 try
            {
                TaskFactory taskFactory = new TaskFactory();
                List<Task> taskList = new List<Task>();
                 
                //线程里面的异常是被吞掉了,因为已经脱离try catch的范围了  如果真想让线程之外的Catch抓到异常, 那么只有使用 WaitAll 抓到多线程里面全部的异常
                //实际开发: 线程里面的action不允许出现异常,自己使用try catch处理好
                for (int i = 0; i < 20; i++)
                {
                    string name = string.Format($"btnThreadCore_Click_{i}");
                    Action<object> act = t =>
                    {
                        try
                        {
                            Thread.Sleep(2000);
                            if (t.ToString().Equals("btnThreadCore_Click_11"))
                            {
                                throw new Exception(string.Format($"{t} 执行失败"));
                            }
                            if (t.ToString().Equals("btnThreadCore_Click_12"))
                            {
                                throw new Exception(string.Format($"{t} 执行失败"));
                            }
                            Console.WriteLine("{0} 执行成功", t);
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"Exception:{ex.Message}"); //
                        }
                    };
                    taskList.Add(taskFactory.StartNew(act, name));
                }
               // Task.WaitAll(taskList.ToArray());使用 WaitAll 捕获多线程里面全部的异常; 但是也不能总是WaitAll, 并且很多业务也不能使用WaitAll来处理
                
            }
            catch (AggregateException aex) //专门处理多线程的异常, 里面的异常有多项
            {
                foreach (var item in aex.InnerExceptions)
                {
                    Console.WriteLine(item.Message);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

 

二. 线程的取消, 

a)   场景: 多个线程并发,某个失败后,希望通知别的线程,都停下来, 尽量使用CancellationTokenSource, 不要自己创建bool变量

 try
            {
                TaskFactory taskFactory = new TaskFactory();
                List<Task> taskList = new List<Task>();

          
                 //多个线程并发,某个失败后,希望通知别的线程,都停下来
                 //task是外部无法中止(中间停止),Thread.Abort不靠谱,因为线程是OS的资源,无法掌控啥时候取消
                 //线程的停止: 线程自己停止自己--公共的访问变量--修改它---线程不断的检测它(延迟少不了)
                 //CancellationTokenSource去标志任务是否取消  Cancel取消   IsCancellationRequested  是否已经取消了
                 //Token 启动Task的时候传入,那么如果Cancel了,这个任务会放弃启动,抛出一个异常
                 // 当一个线程不执行, 后面的线程全部都不能再执行了
                 CancellationTokenSource cts = new CancellationTokenSource();//bool值 //bool flag = true; 线程安全的
                for (int i = 0; i < 40; i++)
                {
                    string name = string.Format("btnThreadCore_Click{0}", i);
                    Action<object> act = t =>
                    {
                        try
                        {
                            //if (cts.IsCancellationRequested)
                            //{
                            //    Console.WriteLine("{0} 取消一个任务的执行", t);
                            //}
                            Thread.Sleep(2000);
                            if (t.ToString().Equals("btnThreadCore_Click11"))
                            {
                                throw new Exception(string.Format("{0} 执行失败", t));
                            }
                            if (t.ToString().Equals("btnThreadCore_Click12"))
                            {
                                throw new Exception(string.Format("{0} 执行失败", t));
                            }
                            if (cts.IsCancellationRequested)//启动40个线程, 每一个线程都检查这个信号量, 是否改任务已经被取消
                            {
                                Console.WriteLine("{0} 放弃执行", t);
                                return;
                            }
                            else
                            {
                                Console.WriteLine("{0} 执行成功", t);
                            }
                        }
                        catch (Exception ex)
                        {
                            cts.Cancel(); //当执行抛出异常后, (t.ToString().Equals("btnThreadCore_Click11")); 将信号量设置为false, 表示取消任务
                            Console.WriteLine(ex.Message);
                        }
                    };
                    taskList.Add(taskFactory.StartNew(act, name, cts.Token));
                    //如果一个线程在启动的时候标识了cts.Token, 当cts.Cancel()时, 如果这个线程还没有启动, 则会被标识为取消一个任务执行; 如果这个线程已经启动, 但是还没有执行, 那么会被放弃执行 
                }
                Task.WaitAll(taskList.ToArray());
                 
            }
            catch (AggregateException aex) //专门处理多线程的异常
            {
                foreach (var item in aex.InnerExceptions)
                {
                    Console.WriteLine(item.Message);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

 

三. 多线程临时变量

for (int i = 0; i < 5; i++)
                {
                    Task.Run(() =>
                      {
                          Thread.Sleep(100);
                          Console.WriteLine(i);  //打印结果 5个5
                      });
                }

                for (int i = 0; i < 5; i++)
                {
                    int k = i;
                    Task.Run(() =>
                    {
                        Thread.Sleep(100);
                        Console.WriteLine(k); //打印结果 4,3,1,2,0
                    });
                }

                //i最后是5      全程就只有一个i  等着打印的时候,i==5
                //k             全程有5个k   分别是0 1 2 3 4 
                //k在外面声明   全程就只有一个k    等着打印的时候,k==4
                int k = 0;
                for (int i = 0; i < 5; i++)
                {
                    //    int k = i;
                    k = i;
                    new Action(() =>
                    {
                        Thread.Sleep(100);
                        Console.WriteLine($"k={k} i={i}");
                    }).BeginInvoke(null, null);
                }

 

 

四. 线程安全:

try
            {
                TaskFactory taskFactory = new TaskFactory();
                List<Task> taskList = new List<Task>();
 
                //如何判断何时加锁: 线程内部声明的变量, 由于不共享的是线程安全的; 但是在线程外部操作的资源由于共享, 则就会造成线程不安全. 比如全局变量/数据库的某个值/磁盘文件
                int TotalCountIn = 0;//TotalCountIn属于线程外部变量, 会有线程安全有问题
                for (int i = 0; i < 10000; i++)//i属于线程外部变量, 会有线程安全有问题
                {
                    int newI = i;//newI 属于线程内部变量, 不会有线程安全有问题
                    taskList.Add(taskFactory.StartNew(() =>
                    {
                       //值类型不能lock
                        lock (btnThreadCore_Click_Lock)//lock后的方法块,任意时刻只有一个线程可以进入  
                        //只能锁引用类型,占用这个引用链接   不要用string 因为享元  , 可能导致锁的是同一块内存区域
                        {   //这里就是单线程
                             
                            this.TotalCount += 1;
                            TotalCountIn += 1;
                            this.IntList.Add(newI);
                        }

                    }));
                }
                Task.WaitAll(taskList.ToArray());
                Console.WriteLine(this.TotalCount);
                Console.WriteLine(TotalCountIn);
                Console.WriteLine(this.IntList.Count());
                #endregion 
            }
            catch (AggregateException aex) //专门处理多线程的异常
            {
                foreach (var item in aex.InnerExceptions)
                {
                    Console.WriteLine(item.Message);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

 

五.   关于Lock变量的写法解释:

//为什么锁的变量要这样写private static readonly object btnThreadCore_Click_Lock = new object();
//private  防止外面也去锁     
//static 全场唯一  
//readonly不准修改, 如果不是readonly有可能会在锁的代码里面修改它  
//object表示引用, 因为lock不能锁值类型

 

 六. 为什么不推荐锁this

 

//lock (this)
//{
//    //this form1的实例  每次实例化是不同的锁,同一个实例是相同的锁
//    //但是这个实例别人也能访问到,别人也能锁定
//    //最好不要锁this
//}

 

七. Lock到底是个什么? 

//Monitor.Enter(btnThreadCore_Click_Lock);
//lock 就是一个语法糖, 类似于monitor的写法, 也就是说可以将lock{ }块中的语句, 放到Monitor的Enter和exit中间
//Monitor.Exit(btnThreadCore_Click_Lock);
Monitor.Enter(btnThreadCore_Click_Lock);
//lock 就是一个语法糖, 类似于monitor的写法, 也就是说可以将lock{ }块中的语句, 放到Monitor的Enter和exit中间
{   //这里就是单线程

     this.TotalCount += 1;
     TotalCountIn += 1;
     this.IntList.Add(newI);
}
Monitor.Exit(btnThreadCore_Click_Lock);

 

八. 不使用lock解决,线程安全问题:

//使用lock 解决的时候,因为只有一个线程可以操作数据, 没有并发, 所以解决了问题    但是牺牲了性能,所以要尽量缩小lock的范围

//解决办法:1.  开发中最好不要有冲突, 能拆分就优先拆分, 比如在1亿条数据中进行操作, 那么可以先将数据拆分成不同的小块, 然后再合并成1亿条数据

//2. 不使用locak, 可以使用安全队列 System.Collections.Concurrent.ConcurrentQueue来解决,   一个线程去完成操作

  

 

以上是关于20181106_线程之异常_取消_变量_安全Lock的主要内容,如果未能解决你的问题,请参考以下文章

阶段1 语言基础+高级_1-3-Java语言高级_05-异常与多线程_第3节 线程同步机制_3_线程安全问题产生的原理

Python ThreadPoolExecutor 异常中止解决方案

Spring Cloud微服务安全实战_3-5_API安全之常见问题

python多线程之Condition(条件变量)

Linux___线程互斥与同步

阶段1 语言基础+高级_1-3-Java语言高级_05-异常与多线程_第4节 等待唤醒机制_8_等待唤醒机制代码实现_包子类&包子铺类