今天记录一下异步多线程的进阶历史，以及简单的使用方法
主要还是以Task，Parallel为主，毕竟用的比较多的现在就是这些了，再往前去的，除非是老项目，不然真的应该是挺少了，大概有个概念，就当了解一下进化史了
1：委托异步多线程，所有的异步都是基于委托来实现的
#region 委托异步多线程{ //委托异步多线程 Stopwatch watch = new Stopwatch(); watch.Start(); Console.WriteLine($"开始执行了,{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ffff")},,,,{Thread.CurrentThread.ManagedThreadId}"); Action<string> act = DoSomethingLong; for (int i = 0; i < 5; i++) { //int ThreadId = Thread.CurrentThread.ManagedThreadId;//获取当前线程ID string name = $"Async {i}"; act.BeginInvoke(name, null, null); } watch.Stop(); Console.WriteLine($"结束执行了,{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ffff")},,,,{watch.ElapsedMilliseconds}");}#endregion
2：多线程的最老版本：Thread（好像是2.0的时候出的？记不得了）
//Thread//Thread默认属于前台线程，启动后必须完成//Thread有很多Api，但大多数都已经不用了Console.WriteLine("Thread多线程开始了");Stopwatch watch = new Stopwatch();watch.Start();//线程容器List<Thread> list = new List<Thread>();for (int i = 0; i < 5; i++){ //int ThreadId = Thread.CurrentThread.ManagedThreadId;//获取当前线程ID string name = $"Async {i}"; ThreadStart start1 = () => { DoSomethingLong(name); }; Thread thread = new Thread(start1); thread.IsBackground = true;//设置为后台线程，关闭后立即退出 thread.Start(); list.Add(thread); //thread.Suspend();//暂停，已经不用了 //thread.Resume();//恢复，已经不用了 //thread.Abort();//销毁线程 //停止线程靠的不是外部力量，而是线程自身，外部修改信号量，线程检测信号量}//判断当前线程状态，来做线程等待while (list.Count(t => t.ThreadState != System.Threading.ThreadState.Stopped) > 0){ Console.WriteLine("等待中.....");
Thread.Sleep(500);}//统计正确全部耗时，通过join来做线程等待foreach (var item in list){ item.Join();//线程等待，表示把thread线程任务join到当前线程，也就是当前线程等着thread任务完成 //等待完成后统计时间}watch.Stop();
Thread的无返回值回调：
封装一个方法
/// <summary>/// 回调封装，无返回值/// </summary>/// <param name="start"></param>/// <param name="callback"></param>private static void ThreadWithCallback(ThreadStart start, Action callback){ ThreadStart nweStart = () => { start.Invoke(); callback.Invoke(); }; Thread thread = new Thread(nweStart); thread.Start();}
//回调的委托Action act = () =>{ Console.WriteLine("回调函数");};//要执行的异步操作ThreadStart start = () =>{ Console.WriteLine("正常执行。。");};ThreadWithCallback(start, act);
有返回值的回调：
/// <summary>/// 回调封装，有返回值/// 想要获取返回值，必须要有一个等待的过程/// </summary>/// <typeparam name="T"></typeparam>/// <param name="func"></param>/// <returns></returns>private static Func<T> ThreadWithReturn<T>(Func<T> func){ T t = default(T); //ThreadStart本身也是一个委托 ThreadStart start = () => { t = func.Invoke(); }; //开启一个子线程 Thread thread = new Thread(start); thread.Start(); //返回一个委托，因为委托本身是不执行的，所以这里返回出去的是还没有执行的委托 //等在获取结果的地方，调用该委托 return () => { //只是判断状态的方法 while (thread.ThreadState != System.Threading.ThreadState.Stopped) { Thread.Sleep(500); } //使用线程等待 //thread.Join(); //以上两种都可以 return t; };}
Func<int> func = () =>{ Console.WriteLine("正在执行。。。"); Thread.Sleep(10000); Console.WriteLine("执行结束。。。"); return DateTime.Now.Year;};Func<int> newfunc = ThreadWithReturn(func);//这里为了方便测试，只管感受回调的执行原理Console.WriteLine("Else.....");Thread.Sleep(100);Console.WriteLine("Else.....");Thread.Sleep(100);Console.WriteLine("Else.....");//执行回调函数里return的委托获取结果//newfunc.Invoke();Console.WriteLine($"有参数回调函数的回调结果：{newfunc.Invoke()}");
关于有返回值的回调，因为委托是在执行Invoke的时候才会去调用委托的方法，所以在调用newfunc.Invoke()的时候，才会去委托里面抓取值，这里会有一个等待的过程，等待线程执行完成
3：ThreadPool:线程池
线程池是在Thread后出的，算是一种很给力的进化
在Thread的年代，线程是直接从计算机里抓取的，而线程池的出现，就是给开发人员提供一个容器，可以从容器中抓取线程，也就是线程池
好处就在于可以避免频繁的创建和销毁线程，直接从线程池拿线程，用完在还回去，当不够的时候，线程池在从计算机中给你分配，岂不是很爽?
线程池的数量是可以控制的，最小线程数量：8
ThreadPool.QueueUserWorkItem(p =>{ //这里的p是没有值的 Console.WriteLine(p); Thread.Sleep(2000); Console.WriteLine($"线程池线程,{Thread.CurrentThread.ManagedThreadId}");});ThreadPool.QueueUserWorkItem(p =>{ //这里的p就是传进来的值 Console.WriteLine(p); Thread.Sleep(2000); Console.WriteLine($"线程池线程，带参数,{Thread.CurrentThread.ManagedThreadId}");}, "这里是参数");
线程池用起来还是很方便的，也可以控制线程数量
线程池里有两种线程：普通线程，IO线程，我比较喜欢在操作IO的时候使用ThreadPool
int workerThreads = 0;int completionPortThreads = 0;//设置线程池的最大线程数量（普通线程，IO线程）ThreadPool.SetMaxThreads(80, 80);//设置线程池的最小线程数量(普通线程，IO线程)ThreadPool.SetMinThreads(8, 8);ThreadPool.GetMaxThreads(out workerThreads, out completionPortThreads);Console.WriteLine($"当前可用最大普通线程:{workerThreads}，IO:{completionPortThreads}");ThreadPool.GetMinThreads(out workerThreads, out completionPortThreads);Console.WriteLine($"当前可用最小普通线程：{workerThreads},IO:{completionPortThreads}");
ThreadPool并没有Thread的Join等待接口，那么想让ThreadPool等待要这么做呢？
ManualResetEvent:通知一个或多个正在等待的线程已发生的事件，相当于发送了一个信号
mre.WaitOne:卡住当前主线程，一直等到信号修改为true的时候，才会接着往下跑
//用来控制线程等待,false默认为关闭状态ManualResetEvent mre = new ManualResetEvent(false);ThreadPool.QueueUserWorkItem(p =>{ DoSomethingLong("控制线程等待"); Console.WriteLine($"线程池线程，带参数,{Thread.CurrentThread.ManagedThreadId}"); //通知线程，修改信号为true mre.Set();});//阻止当前线程，直到等到信号为true在继续执行mre.WaitOne();//关闭线程，相当于设置成falsemre.Reset();Console.WriteLine("信号被关闭了");ThreadPool.QueueUserWorkItem(p =>{ Console.WriteLine("再次等待"); mre.Set();});mre.WaitOne();
4：Task，这也是现在用的最多的了，比较是比较新的玩意
关于Task就介绍几个最常用的接口，基本上就够用了（一招鲜吃遍天）
Task.Factory.StartNew:创建一个新的线程，Task的线程也是从线程池中拿的（ThreadPool）
Task.WaitAny:等待一群线程中的其中一个完成，这里是卡主线程，一直等到一群线程中的最快的一个完成，才能继续往下执行（20年前我也差点被后面的给追上），打个简单的比方：从三个地方获取配置信息（数据库，config，IO），同时开启三个线程来访问，谁快我用谁。
Task.WaitAll:等待所有线程完成，这里也是卡主线程，一直等待所有子线程完成任务，才能继续往下执行。
Task.ContinueWhenAny:回调形式的，任意一个线程完成后执行的后续动作，这个就跟WaitAny差不多，只不是是回调形式的。
Task.ContinueWhenAll:回调形式的，所有线程完成后执行的后续动作，理解同上
//线程容器
List<Task> taskList = new List<Task>();Stopwatch watch = new Stopwatch();watch.Start();Console.WriteLine("************Task Begin**************");//启动5个线程for (int i = 0; i < 5; i++){ string name = $"Task:{i}"; Task task = Task.Factory.StartNew(() => { DoSomethingLong(name); }); taskList.Add(task);}//回调形式的，任意一个完成后执行的后续动作Task any = Task.Factory.ContinueWhenAny(taskList.ToArray(), task =>{ Console.WriteLine("ContinueWhenAny");});//回调形式的，全部任务完成后执行的后续动作Task all = Task.Factory.ContinueWhenAll(taskList.ToArray(), tasks =>{ Console.WriteLine($"ContinueWhenAll{tasks.Length}");});//把两个回调也放到容器里面，包含回调一起等待taskList.Add(any);taskList.Add(all);//WaitAny:线程等待，当前线程等待其中一个线程完成Task.WaitAny(taskList.ToArray());Console.WriteLine("WaitAny");//WaitAll:线程等待，当前线程等待所有线程的完成Task.WaitAll(taskList.ToArray());Console.WriteLine("WaitAll");Console.WriteLine($"************Task End**************{watch.ElapsedMilliseconds},{Thread.CurrentThread.ManagedThreadId}");
关于Task其实只要熟练掌握这几个接口，基本上就够了，完全够用
5：Parallel（并行编程）：其实就是在Task基础上又进行了一次封装，当前，Parallel也有很酷炫功能
问：首先是为什么叫做并行编程，跟Task有什么区别？
答：使用Task开启子线程的时候，主线程是属于空闲状态，并不参与执行（我是领导，有5件事情需要处理，我安排了5个手下去做，而我本身就是观望状态 PS：到底是领导。），Parallel开启子线程的时候，主线程也会参与计算（我是领导，我有5件事情需要处理，我身为领导，但是我很勤劳，所以我做了一件事情，另外四件事情安排4个手下去完成），很明显，减少了开销。
你以为Parallel就只有这个炫酷的功能？大错特错，更炫酷的还有；
Parallel可以控制线程的最大并发数量，啥意思？就是不管你是脑溢血，还是心脏病，还是动脉大出血，我的手术室只有2个，同时也只能给两个人做手术，做完一个在进来一个，同时做完两个，就同时在进来两个，多了不行。
当前，你想使用Task，或者ThreadPool来实现这样的效果也是可以的，不过这就需要你动动脑筋了，当然，有微软给封装好的接口直接使用，岂不美哉？
//并行编程 Console.WriteLine($"*************Parallel start********{Thread.CurrentThread.ManagedThreadId}****");//一次性执行1个或多个线程，效果类似：Task WaitAll，只不过Parallel的主线程也参与了计算Parallel.Invoke( () => { DoSomethingLong("Parallel`1"); }, () => { DoSomethingLong("Parallel`2"); }, () => { DoSomethingLong("Parallel`3"); }, () => { DoSomethingLong("Parallel`4"); }, () => { DoSomethingLong("Parallel`5"); });//定义要执行的线程数量Parallel.For(0, 5, t =>{ int a = t; DoSomethingLong($"Parallel`{a}");});{ ParallelOptions options = new ParallelOptions() { MaxDegreeOfParallelism = 3//执行线程的最大并发数量,执行完成一个，就接着开启一个 }; //遍历集合，根据集合数量执行线程数量 Parallel.ForEach(new List<string> { "a", "b", "c", "d", "e", "f", "g" }, options, t => { DoSomethingLong($"Parallel`{t}"); });}{ ParallelOptions options = new ParallelOptions() { MaxDegreeOfParallelism = 3//执行线程的最大并发数量,执行完成一个，就接着开启一个 }; //遍历集合，根据集合数量执行线程数量 Parallel.ForEach(new List<string> { "a", "b", "c", "d", "e", "f", "g" }, options, (t, status) => { //status.Break();//这一次结束。 //status.Stop();//整个Parallel结束掉，Break和Stop不可以共存 DoSomethingLong($"Parallel`{t}"); });}Console.WriteLine("*************Parallel end************");
可以多了解一下Parallel的接口，里面的用法有很多，我这里也只是列出了比较常用的几个，像ParallelOptions类可以控制并发数量，当然，不可以也可以，Parallel的重载方法很多，可以自己看看
6：线程取消，异常处理
关于线程取消这块呢，要记住一点，线程只能自身终结自身，也就是除非我自杀，否则你干不掉我，不要妄想通过主线程来控制计算中的子线程。
关于线程异常处理这块呢，想要捕获子线程的异常，最好在子线程本身抓捕，也可以使用Task的WaitAll，不过这种方法不推荐，如果用了，别忘了一点，catch里面放的是AggregateException，不是Exception，不然捕捉不到别怪我
TaskFactory taskFactory = new TaskFactory();//通知线程是否取消CancellationTokenSource cts = new CancellationTokenSource();List<Task> taskList = new List<Task>();//想要主线程抓捕到子线程异常，必须使用Task.WaitAll，这种方法不推荐//想要捕获子线程的异常，最好在子线程本身抓捕//完全搞不懂啊，看懵逼了都try{ for (int i = 0; i < 40; i++) { int name = i; //在子线程中抓捕异常 Action<object> a = t => { try { Thread.Sleep(2000); Console.WriteLine(cts.IsCancellationRequested); if (cts.IsCancellationRequested) { Console.WriteLine($"放弃执行{name}"); } else { if (name == 1) { throw new Exception($"取消了线程{name}{t}"); } if (name == 5) { throw new Exception($"取消了线程{name}{t}"); } Console.WriteLine($"执行成功:{name}"); } } catch (Exception ex) { //通知线程取消，后面的都不执行 cts.Cancel(); Console.WriteLine(ex.Message); } }; taskList.Add(taskFactory.StartNew(a, name, cts.Token)); } Task.WaitAll(taskList.ToArray());}catch (AggregateException ex){ foreach (var item in ex.InnerExceptions) { Console.WriteLine(item.Message); }}
7：给线程上个锁，防止并发的时候数据丢失，覆盖等
//先准备三个公共变量private static int iIndex;private static object obj = new object();private static List<int> indexList = new List<int>();
List<Task> taskList = new List<Task>();//开启1000个线程for (int i = 0; i < 10000; i++){ int newI = i; Task task = Task.Factory.StartNew(() => { iIndex += 1; indexList.Add(newI); }); taskList.Add(task);}//等待所有线程完成Task.WhenAll(taskList.ToArray());//打印结果Console.WriteLine(iIndex);Console.WriteLine(indexList.Count);
给你们看一下我这里运行三次打印出的结果
第一次：
第二次：
第三次：
看的出来，还是比较稳定的只丢失那么几个数据的对吧？
为啥会这样呢？因为当两个线程同时操作一个数据的时候，你觉得会以谁的操作为标准来保存？就好像我们操作IO的时候，不允许多多个线程同时操作一个IO，因为计算机不知道以谁的标准来保存修改
下面给它加个锁，稍微修改一下代码：
List<Task> taskList = new List<Task>();//开启1000个线程for (int i = 0; i < 10000; i++){ int newI = i; Task task = Task.Factory.StartNew(() => { //加个锁 lock (objLock) { iIndex += 1; indexList.Add(newI); } }); taskList.Add(task);}//等待所有线程完成Task.WhenAll(taskList.ToArray());//打印结果Console.WriteLine(iIndex);Console.WriteLine(indexList.Count);
在看一下运行结果：
线程锁会破坏线程，增加耗时，降低效率，不要看效果很爽就到处加锁，万一你钥匙丢了呢（死锁）；
共有变量：都能访问的局部变量/全局变量/数据库的值/硬盘文件，这些都有可能是数据不安全的，如果有需求，还是得加个锁
如果确实是要用到锁，推荐大家就使用一个：私有的，静态的，object类型的变量就可以了；
漏掉了一个方法，我给补上：
/// <summary>/// 一个比较耗时的方法,循环1000W次/// </summary>/// <param name="name"></param>public static void DoSomethingLong(string name){ int iResult = 0; for (int i = 0; i < 1000000000; i++) { iResult += i; } Console.WriteLine($"********************{name}*******{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ffff")}****{Thread.CurrentThread.ManagedThreadId}****");}
注：本文内容来自互联网，旨在为开发者提供分享、交流的平台。如有涉及文章版权等事宜，请你联系站长进行处理。