.NET 异步多线程，Thread，ThreadPool，Task，Parallel

今天记录一下异步多线程的进阶历史，以及简单的使用方法

主要还是以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();
//关闭线程，相当于设置成false
mre.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}****");
}