8异步和多线程

1，.NET 中实现异步的方式是使用委托的beginInvoke方法。

使用异步之后.net会创建一个线程来异步执行方法操作，主线程会继续执行程序逻辑。如果在异步执行中有回调函数，在异步方法执行完之后执行异步调用的线程回再执行回调函数中的代码。

1，首先创建一个比较耗时的私有方法用以作为异步执行的代码，后续的多线程执行代码使用的也是该代码。

/// <summary>
        /// 一个比较耗时耗资源的私有方法
        /// </summary>
        /// <param name="name"></param>
        private void DoSomethingLong(string name)
        {
            Console.WriteLine($"****************DoSomethingLong Start {name} {System.Threading.Thread.CurrentThread.ManagedThreadId}***************");
            long lResult = 0;
            for (int i = 0; i < 1000000000; i++)
            {
                lResult += i;
            }
            //Thread.Sleep(2000);

            Console.WriteLine($"****************DoSomethingLong   End  {name} {System.Threading.Thread.CurrentThread.ManagedThreadId}***************");
        }

然后声明一个委托，用私有方法实例化，调用代码如下：

Action<string> act = this.DoSomethingLong;

                AsyncCallback callback = t =>
                {
                    Console.WriteLine("t的值为：" + t);
                    Console.WriteLine($"执行callback回调函数的线程是{System.Threading.Thread.CurrentThread.ManagedThreadId}");
                };
                IAsyncResult asyncResult = act.BeginInvoke("btnasync_Click", callback, "标识参数");

                Console.WriteLine("异步之外的函数执行1");
                Console.WriteLine("异步之外的函数执行2");
                Console.WriteLine("异步之外的函数执行3");
                act.EndInvoke(asyncResult);

执行效果：

执行效果可以看出，异步线程执行私有的耗时方法，主线程直接执行下面的打印方法，在异步方法执行完毕之后子线程又执行了回调函数。

2，使用Thread方式执行多线程

 private Func<T> ThreadWithReturn<T>(Func<T> func) {
            T t = default(T);
            ThreadStart threadStart = () => {
                func.Invoke();
            };
            System.Threading.Thread thread = new System.Threading.Thread(threadStart);
            thread.Start();
            return new Func<T>(() =>{
                thread.Join(); //让当前线程加入到主线程中
                return t;
            });
        } 

调用：

 Func<int> funcInvoke = this.ThreadWithReturn<int>(func);
            Console.WriteLine("执行其他的操作1");
            System.Threading.Thread.Sleep(1000);
            Console.WriteLine("执行其他的操作2");
            System.Threading.Thread.Sleep(1000);
            Console.WriteLine("执行其他的操作3");
            Console.WriteLine(funcInvoke.Invoke()); 

3，ThreadPool线程池方式执行多线程

ThreadPool.QueueUserWorkItem(t=>{});   开辟一条线程执行方法函数

实例化ManualResetEvent 类，通过实例化对象调用Set() ,Reset()  ，waiteOne() 方法等待ManualResetEvent对象变成true时才会执行下面的方法。

 private void ThreadPool_Click(object sender, EventArgs e)
        {
            //线程池
            {
                Console.WriteLine($"-------线程池执行开始------ {System.Threading.Thread.CurrentThread.ManagedThreadId}");
                ManualResetEvent mre = new ManualResetEvent(false); //设置线程池运行信号量，传递false代表关闭状态
                ThreadPool.QueueUserWorkItem(t =>
                {
                    Console.WriteLine("t的值是："+t);
                    this.DoSomethingLong("ThreadPool_Click");
                    Console.WriteLine("子线程的线程ID是：" + System.Threading.Thread.CurrentThread.ManagedThreadId);
                    mre.Set(); //打开
                               //mre.Reset();//关闭
                });
                mre.WaitOne(); //等待所有线程执行完毕再执行下面的逻辑，会卡住页面线程
            }

            //ThreadPool.SetMaxThreads(8, 8); //设置最大工作线程数量和IO线程数量。
            //ThreadPool.SetMinThreads(8, 8);
            #region ManualResetEvent
            {
                ManualResetEvent mre = new ManualResetEvent(false);  //初始化关闭
                System.Threading.ThreadPool.QueueUserWorkItem(t =>
                {
                    System.Threading.Thread.Sleep(2000);
                    Console.WriteLine("第一次执行线程暂停2000ms");
                    mre.Set();//打开
                });
                mre.WaitOne(); 
                mre.Reset();//关闭
                new Action(() =>
                {
                    System.Threading.Thread.Sleep(2000);
                    Console.WriteLine("第二次执行线程暂停2000ms");
                    mre.Set();
                }).BeginInvoke(null, null);
                mre.WaitOne();
            }
            #endregion
            Console.WriteLine($"-------线程池执行结束------ {System.Threading.Thread.CurrentThread.ManagedThreadId}");
        }

4，Task方式执行多线程

Task.Factory.StartNew(() => { this.DoSomethingLong(name); });   开辟一条新的执行线程

ContinueWhenAll和ContinueWhenAny都是异步方式执行的调用，都不会卡主线程。

Task.Factory.ContinueWhenAll(taskList.ToArray(),tList=>{doCallBack。。。});//所有任务执行完成之后再调用回调函数。

Task.Factory.ContinueWhenAny(taskList.ToArray(),t=>{doCallBack。。。});//任意一个任务执行完成之后再调用回调函数。

WaiteAll和WaiteAny都是同步方式执行的调用，都会卡住主线程。

Task.WaiteAll(taskList.ToArray()); //所有任务完成后再执行后面的代码，会卡主线程

Task.WaiteAny(taskList.ToArray()); //任意任务完成后再执行后面的代码，会卡主线程

private void Task_Click(object sender, EventArgs e)
        {
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine($"------------Task 执行开始 当前线程是：{System.Threading.Thread.CurrentThread.ManagedThreadId}----------"); 
            List<Task> taskList = new List<Task>();
            for (int i = 0; i < 5; i++)
            {
                string name = string.Format("Task_Click"+i); 
               Task taskNew =  Task.Factory.StartNew(() => {
                    this.DoSomethingLong(name);
                });
                taskList.Add(taskNew); 
            }
            //等待所有任务都完成再调用回调方法，不会卡主线程
            //Task.Factory.ContinueWhenAll(taskList.ToArray(), tList =>
            //{
            //    Console.WriteLine($"所有任务都执行完毕后调用的回调方法{System.Threading.Thread.CurrentThread.ManagedThreadId}");
            //});

            //任意一个任务执行完成就调用，不会卡主线程
            //Task.Factory.ContinueWhenAny(taskList.ToArray(), t =>
            //{
            //    Console.WriteLine(t);
            //    Console.WriteLine($"任意一个任务执行完毕后调用的回调方法{System.Threading.Thread.CurrentThread.ManagedThreadId}");
            //});

             Task.WaitAll(taskList.ToArray());   //等待所有任务完成会卡主线程
            // Task.WaitAny(taskList.ToArray());   //等待任意一个任务完成

            Console.WriteLine($"------------Task 执行结束 当前线程是：{System.Threading.Thread.CurrentThread.ManagedThreadId}----------");
        }

5，异常处理，线程取消，多线程的临时变量和线程安全 lock

/// <summary>
        /// 异常处理，线程取消，多线程的临时变量和线程安全 lock
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ThreadCore_Click(object sender, EventArgs e)
        {
            List<Task> taskList = new List<Task>();
            
            try
            {
                #region 线程中的异常处理
                //for (int i = 0; i < 20; i++)
                //{
                //    string name = string.Format($"ThreadCore_Click_{i}");
                //    Action<object> act = t =>
                //    {
                //        try
                //        {
                //            System.Threading.Thread.Sleep(1000);
                //            if (t.Equals("ThreadCore_Click_11"))
                //            {
                //                throw new Exception("ThreadCore_Click_11_Exception");
                //            }
                //            if (t.Equals("ThreadCore_Click_12"))
                //            {
                //                throw new Exception("ThreadCore_Click_12_Exception");
                //            }
                //            Console.WriteLine($"{name} ,执行成功！");
                //        }
                //        catch (Exception ex)
                //        {
                //            //在线程Action加try catch,记录日志，不抛异常。
                //        }
                //    };
                //    taskList.Add(Task.Factory.StartNew(act, name));
                //}
                //Task.WaitAll(taskList.ToArray());  //加上WaitAll
                #endregion

                #region 线程取消
                // 线程间通信都是通过共有变量：都能访问局部变量/全局变量，数据库值，硬盘文件
                //CancellationTokenSource cts = new CancellationTokenSource();  //线程是否取消,用信号量标记

                //for (int i = 0; i < 40; i++)
                //{
                //    string name = string.Format($"ThreadCore_Click{i}");
                //    Action<object> act = t =>
                //    {
                //        try
                //        {
                //            System.Threading.Thread.Sleep(2000);
                //            Console.WriteLine($"当前线程为：{System.Threading.Thread.CurrentThread.ManagedThreadId}");
                //            if (t.Equals("ThreadCore_Click11"))
                //            {
                //                throw new Exception("ThreadCore_Click11 执行失败");
                //            }
                //            if (t.Equals("ThreadCore_Click12"))
                //            {
                //                throw new Exception("ThreadCore_Click12 执行失败");
                //            }
                //            if (cts.IsCancellationRequested) //查看当前线程是否已经被取消
                //            {
                //                Console.WriteLine("取消执行" + t);
                //            }
                //            else
                //            {
                //                Console.WriteLine("执行成功" + t);
                //            }
                //        }
                //        catch (Exception ex)
                //        {
                //            cts.Cancel();//出现异常设置未执行的线程取消。
                //            throw;
                //        }
                //    };
                //    taskList.Add(Task.Factory.StartNew(act, name, cts.Token));  //将 cts.Token 传递到执行线程中用以判断
                //}
                //Task.WaitAll(taskList.ToArray());   //必须添加
                #endregion

                #region 多线程临时变量
                //for (int i = 0; i < 5; i++)
                //{
                //    int k = i;
                //    new Action(()=> {
                //        System.Threading.Thread.Sleep(100);
                //        //Console.WriteLine(i);
                //        Console.WriteLine(k);
                //    }).BeginInvoke(null,null);
                //}
                #endregion

                #region 线程安全
                for (int i = 0; i < 10000; i++)
                {
                    int newI = i;
                   taskList.Add(Task.Factory.StartNew(() =>
                    {
                        lock (threadLock) //lock后面的方法块任意时刻只有一个线程进来，此时就变成了单线程。
                        {
                            IntTotal += 1;
                        }
                    }));
                }
                Task.WaitAll(taskList.ToArray());
                Console.WriteLine($"IntTotal:{IntTotal}");
                IntTotal = 0;
                #endregion
            }
            catch (AggregateException ex)
            {
                foreach (var item in ex.InnerExceptions)
                {
                    Console.WriteLine($"异常信息为：" + item.Message);
                }
            }
            catch (Exception ex)
            {
                throw;
            }
        }