C# 多线程总结 异常处理 线程取消 锁（lock）

那么什么时候能用多线程？ 任务能并发的时候

多线程能干嘛？提升速度/优化用户体验

网站首页：A数据库 B接口 C分布式服务 D搜索引擎，适合多线程并发，都完成后才能返回给用户，需要等待WaitAll
列表页：核心数据可能来自数据库/接口服务/分布式搜索引擎/缓存，多线程并发请求，哪个先完成就用哪个结果，其他的就不管了

现实实例

多人合作开发---多线程--提升效率/性能

              {
                TaskFactory taskFactory = new TaskFactory();
                List<Task> taskList = new List<Task>();
                taskList.Add(taskFactory.StartNew(o=> Coding("A", " Portal"), "A"));
                taskList.Add(taskFactory.StartNew(o=> Coding("B", "    DBA"), "B"));
                taskList.Add(taskFactory.StartNew(o=> Coding("C", " Client"), "C"));
                taskList.Add(taskFactory.StartNew(o=> Coding("D", "Service"), "D"));
                taskList.Add(taskFactory.StartNew(o=> Coding("E", " Wechat"), "E"));

                //谁第一个完成，获取一个红包奖励
                taskFactory.ContinueWhenAny(taskList.ToArray(), t => Console.WriteLine($"{t.AsyncState}开发完成，获取个红包奖励{Thread.CurrentThread.ManagedThreadId.ToString("00")}"));
                //实战作业完成后，一起庆祝一下
                taskList.Add(taskFactory.ContinueWhenAll(taskList.ToArray(), rArray => Console.WriteLine($"开发都完成，一起庆祝一下{Thread.CurrentThread.ManagedThreadId.ToString("00")}")));
                //ContinueWhenAny  ContinueWhenAll 非阻塞式的回调；而且使用的线程可能是新线程，也可能是刚完成任务的线程，唯一不可能是主线程


                //阻塞当前线程，等着任意一个任务完成
                Task.WaitAny(taskList.ToArray());//也可以限时等待
                Console.WriteLine("准备环境开始部署");
                //需要能够等待全部线程完成任务再继续  阻塞当前线程，等着全部任务完成
                Task.WaitAll(taskList.ToArray());
                Console.WriteLine("5个模块全部完成后，集中调试");

                //Task.WaitAny  WaitAll都是阻塞当前线程，等任务完成后执行操作
                //阻塞卡界面，是为了并发以及顺序控制
            }

        /// <summary>
        /// 模拟Coding过程
        /// </summary>
        /// <param name="name"></param>
        /// <param name="projectName"></param>
        private static string Coding(string name, string projectName)
        {
            Console.WriteLine($"****************Coding Start  {name} {projectName}  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");
            long lResult = 0;
            for (int i = 0; i < 1_000_000_000; i++)
            {
                lResult += i;
            }
            Console.WriteLine($"****************Coding   End  {name} {projectName} {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} {lResult}***************");
            return name;
        }

多线程异常处理

            #region 多线程异常处理
            {
                try
                {

                    List<Task> taskList = new List<Task>();
                    for (int i = 0; i < 100; i++)
                    {
                        string name = $"btnThreadCore_Click_{i}";
                        taskList.Add(Task.Run(() =>
                        {
                            if (name.Equals("btnThreadCore_Click_11"))
                            {
                                throw new Exception("btnThreadCore_Click_11异常");
                            }
                            else if (name.Equals("btnThreadCore_Click_12"))
                            {
                                throw new Exception("btnThreadCore_Click_12异常");
                            }
                            else if (name.Equals("btnThreadCore_Click_38"))
                            {
                                throw new Exception("btnThreadCore_Click_38异常");
                            }
                            Console.WriteLine($"This is {name}成功 ThreadId={Thread.CurrentThread.ManagedThreadId.ToString("00")}");
                        }));
                    }
                    //多线程里面抛出的异常，会终结当前线程；但是不会影响别的线程；
                    //那线程异常哪里去了？ 被吞了，
                    //假如我想获取异常信息，还需要通知别的线程
                    Task.WaitAll(taskList.ToArray());//1 可以捕获到线程的异常
                }
                catch (AggregateException aex)//2 需要try-catch-AggregateException
                {
                    foreach (var exception in aex.InnerExceptions)
                    {
                        Console.WriteLine(exception.Message);
                    }
                }
                catch (Exception ex)//可以多catch  先具体再全部
                {
                    Console.WriteLine(ex);
                }
                //线程异常后经常是需要通知别的线程，而不是等到WaitAll，问题就是要线程取消
                //工作中常规建议：多线程的委托里面不允许异常，包一层try-catch,然后记录下来异常信息，完成需要的操作
            }
            #endregion

多线程里面抛出的异常，会终结当前线程；但是不会影响别的线程；线程异常哪里去了？ 被吞了

多线程的委托里面不允许异常，包一层try-catch,然后记录下来异常信息 ，通知别的线程

线程取消

              {
                CancellationTokenSource cts = new CancellationTokenSource();
                var token = cts.Token; cts.Cancel();
                CancellationTokenSource cts2 = new CancellationTokenSource();
                var token2 = cts2.Token;
                List<Task> taskList = new List<Task>();
                for (int i = 0; i < 10; i++)
                {
                    int k = i;
                    switch (i%5)
                    {
                        case 0:
                            taskList.Add(Task.Run(() => { Console.WriteLine($"i={i},k={k},i%5=0"); }));break;
                        case 1: 
                            taskList.Add(Task.Run(() => { Console.WriteLine($"i={i},k={k},i%5=1"); },token)); break;
                        case 2: 
                            taskList.Add(Task.Run(() => { Console.WriteLine($"i={i},k={k},i%5=2"); }, token2)); break;
                        case 3:
                            taskList.Add(Task.Run(() => { Console.WriteLine($"i={i},k={k},i%5=3"); })); break;
                        case 4:
                            taskList.Add(Task.Run(() => { Console.WriteLine($"i={i},k={k},i%5=4");
                                throw new Exception("throw new Exception");
                            })); break;
                    }
                }
                //Thread.Sleep(500);
                cts2.Cancel();
                try
                {
                    Task.WaitAll(taskList.ToArray());
                }catch(AggregateException ae)
                {
                    foreach (var item in ae.InnerExceptions)
                    {
                        Console.WriteLine($"{item.GetType().Name}:{item.Message}");
                    }
                }
                Console.WriteLine("**********************************");
                foreach (var item in taskList)
                {
                    Console.WriteLine($"Id:{item.Id},Status:{item.Status}");
                    if (item.Exception != null)
                    {
                        foreach (var ex in item.Exception.InnerExceptions)
                        {
                            Console.WriteLine($"{ex.GetType().Name}:{ex.Message}");
                        }
                    }
                }
            }

运行上面的代码，有四个任务被取消，取消注释，则有两个任务被取消

线程安全

如果你的代码在进程中有多个线程同时运行这一段，如果每次运行的结果都跟单线程运行时的结果一致，那么就是线程安全的
线程安全问题一般都是有全局变量/共享变量/静态变量/硬盘文件/数据库的值，只要多线程都能访问和修改

Lock

1、Lock解决多线程冲突

Lock是语法糖，Monitor.Enter,占据一个引用，别的线程就只能等着 

推荐锁是private static readonly object

A 不能是Null，可以编译不能运行;

B 不推荐lock(this),外面如果也要用实例，就冲突了

    public class LockHelper
    {
        public void Show()
        {
            LockTest test = new LockTest();
            Console.WriteLine(DateTime.Now);
            Task.Delay(10).ContinueWith(t =>
            {
                lock (test)
                {
                    Console.WriteLine($"*********Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}********");
                    Thread.Sleep(5000);
                    Console.WriteLine($"*********End   {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}********");
                }
            });
            test.LockThis();
        }
    }
    public class LockTest
    {
        private int lockthis;
        public void LockThis()
        {
            lock (this)
            //递归调用，lock this  会不会死锁？ 不会死锁！
            //这里是同一个线程，这个引用就是被这个线程所占据
            {
                Thread.Sleep(1000);
                this.lockthis++;
                if (this.lockthis < 10)
                    this.LockThis();
                else
                    Console.WriteLine($"This is  {nameof(LockThis)}:{this.lockthis} {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}");
            }
        }
    }

这里LockThis自身递归调用不会死锁，这个引用被当前线程占用，但当另外的实例要使用时就冲突了，必须等待LockThis执行完成后，释放当前实例，外面的实例才能被调用

C 不应该是string； string在内存分配上是重用的，会冲突

            {
                LockTest test = new LockTest();
                Console.WriteLine(DateTime.Now);
                string lockString = "lockString";
                Task.Delay(1000).ContinueWith(t =>
                {
                    lock (lockString)
                    {
                        Console.WriteLine($"****lockString Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}********");
                        Thread.Sleep(5000);
                        Console.WriteLine($"****lockString End   {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}********");
                    }
                });
                test.LockString();
            }
    public class LockTest
    {
        private int lockthis;
        public void LockThis()
        {
            lock (this)
            //递归调用，lock this  会不会死锁？ 不会死锁！
            //这里是同一个线程，这个引用就是被这个线程所占据
            {
                Thread.Sleep(1000);
                this.lockthis++;
                if (this.lockthis < 10)
                    this.LockThis();
                else
                    Console.WriteLine($"This is  {nameof(LockThis)}:{this.lockthis} {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}");
            }
        }

        private string lockString= "lockString";
        public void LockString()
        {
            lock (lockString)
            {
                Thread.Sleep(2000);
                Console.WriteLine($"This is  {nameof(LockString)}:{this.lockString} {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}");
                Thread.Sleep(2000);
            }
        }
    }

String类型在内存分配上按享元模式设计的，某个字符串被占用，其他线程就必须等待字符串释放后才能使用

D Lock里面的代码不要太多，这里是单线程的

2、线程安全集合

System.Collections.Concurrent.ConcurrentQueue<T>

3、 数据分拆，避免多线程操作同一个数据；又安全又高效

        private int _sync = 0;
        private int _async = 0;
        private List<int> listInt = new List<int>();
        private static readonly object lockObject = new object();
        public void LockObject()
        {
            for (int i = 0; i < 1000; i++)
            {
                this._sync++;
            }
            for (int i = 0; i < 1000; i++)
            {
                Task.Run(() => this._async++);
            }
            for (int i = 0; i < 1000; i++)
            {
                int k = i;
                Task.Run(() => this.listInt.Add(k));
            }
            Thread.Sleep(5 * 1000);
            Console.WriteLine($"_sync={this._sync} _async={this._async} listInt={this.listInt.Count}");
        }

运行上面的代码发现_sync=1000  _async与listInt集合个数都少于1000

        public void LockObject()
        {
            for (int i = 0; i < 1000; i++)
            {
                this._sync++;
            }
            for (int i = 0; i < 1000; i++)
            {
                Task.Run(() => {
                    lock (lockObject)
                    {
                        this._async++;
                    }
                });
            }
            for (int i = 0; i < 1000; i++)
            {
                int k = i;
                Task.Run(() => {
                    lock (lockObject)
                    {
                        this.listInt.Add(k);
                    }
                });
            }
            Thread.Sleep(5 * 1000);
            Console.WriteLine($"_sync={this._sync} _async={this._async} listInt={this.listInt.Count}");
        }

使用lock包装后 _async与listInt集合个数都为1000， 使用lock后 只有一个线程才能进入lock方法块内，相当于把程序又变回了单线程

微软文档：

lock:https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/lock-statement

CancellationTokenSource：https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.cancellationtokensource?view=netframework-4.8

CancellationToken：https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.cancellationtoken?view=netframework-4.8