.NET 异步多线程

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

主要还是以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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2、多线程的最老版本：Thread

//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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

有返回值的回调：

/// <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()}");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

关于有返回值的回调，因为委托是在执行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}");

}, "这里是参数");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

线程池用起来还是很方便的，也可以控制线程数量

线程池里有两种线程：普通线程，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}");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

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}");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

关于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************");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

可以多了解一下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);

　　}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

给你们看一下我这里运行三次打印出的结果

第一次：

第二次：

第三次：

看的出来，还是比较稳定的只丢失那么几个数据的对吧？

为啥会这样呢？因为当两个线程同时操作一个数据的时候，你觉得会以谁的操作为标准来保存？

就好像我们操作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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

在看一下运行结果：

线程锁会破坏线程，增加耗时，降低效率，不要看效果很爽就到处加锁，万一你钥匙丢了呢（死锁）；

共有变量：都能访问的局部变量/全局变量/数据库的值/硬盘文件，这些都有可能是数据不安全的，如果有需求，还是得加个锁

如果确实是要用到锁，推荐大家就使用一个：私有的，静态的，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}****");

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

来源：隐于深巷丶
cnblogs.com/liuqiwang/p/8413667.html