C#多线程

1：通过委托启动线程（委托的BeginInvoke和EndInvoke方法）

提到委托，就要用常见的泛型委托Action和Func了
Action委托：
是泛型的，有参数没有返回值，<>内参数类型就是方法里的参数类型
Func委托：
也是泛型的，有参数有返回值，<>中前面是方法的参数类型，最后一个是返回值类型
使用这两个泛型委托，就不用自己去定义，很方便。

首先定义一个方法：

1
2
3
4
5
6
1   static void fun(string s)

2   {

3       Console.WriteLine("fun："+s);

4   }

5

6

然后定义一个委托启动线程

1
2
3
4
5
6
7
1   Action<string> a = fun;

2   a.BeginInvoke("参数1",null,null);

3

4   //Thread.Sleep(1000);

5   Console.WriteLine("main");

6

7

看输出结果，是main先输出，不是顺序执行的，是异步的，不确定的，取决于系统调用，可能Main线程快，可能子线程执行快
上面的项目是.Net Framework项目（学习时是VS2017，创建项目好像只有.NetFramework，然后回家整理，发现.Net Core不支持，报错了，顺便说下，VS2019界面很大改动，喜欢尝鲜的可以试试），而.Net Core实现跨平台，很多旧方法都会重写，不支持BeginInvoke，自己电脑装了VS2019，创建项目是选择了.Net Core控制台项目
运行报错了
差点以为哪里写错了，好了，继续学习，整理知识。

获取方法返回值

那么开启线程执行**有返回值**的方法，怎么获取返回值呢？ 直接接受BeginInvoke? 肯定是不行的，异步方法也要等执行完毕才能返回，只有等线程执行完了才能得到返回值，那么如何检测线程的状态呢？比如是否结束

1）：通过BeginInvoke返回的IAsyncResult的IsCompleted属性
BeginInvoke返回的类型是IAsyncResult，IAsyncResult可以获取进程的状态，它的IsCompleted属性可以判断进程是否执行结束了，一般创建线程去单独完成某项任务，都是比较耗时的，比如下载文件，为了模拟这种情况，给fun1加上Thread.Sleep(3000),然后在Main里每隔一段时间就判断线程是否执行完毕，没有就输出“.”
线程执行完毕了就可以取得结果了：

1
2
3
4
5
6
7
8
9
10
11
1   Func<string, string> f = fun1;

2   var s = f.BeginInvoke("参数2", null, null);

3   while (!s.IsCompleted)

4   {

5       Thread.Sleep(500);

6       Console.Write(".");

7    }

8     Console.WriteLine();

9     Console.WriteLine(f.EndInvoke(s));

10

11

2): 通过等待句柄获取
s的AsyncWaitHandle有个WaitOne方法，会等待进程结束，可以设置超时时间，如果在此时间内线程还未结束 ，那么这个方法就不会再等待，返回false，如果此时间内线程结束了，那么WaitOne方法在线程结束后就会返回true，所以等待时间是小于等于超时时间的

1
2
3
4
5
6
7
8
9
10
11
12
1   var isEnd = s.AsyncWaitHandle.WaitOne(3500);

2    if (isEnd)

3    {

4         var res = f.EndInvoke(s);

5         Console.WriteLine("通过等待句柄获取返回值：" + res);

6    }

7    else

8    {

9         Console.WriteLine("线程超时");

10    }

11

12

3): 通过回调函数获取
BeginInvoke方法中最后两个参数，前面没有用到，传的是null，那么这两个参数是干嘛的呢？？倒数第二个参数是AsyncCallback类型，即异步回调函数，最后一个参数是Object类型；
当线程结束时就会调用传入的回调函数，这个回调函数有一个参数，是定义好的，是IAsyncResult类型的，调用回调函数时系统会自动传入（这里就是传入f1.BeginInvoke的返回值）

1
2
3
4
5
6
7
8
9
10
1   Func<string, string> f1 = fun1;

2    //Lambda表达式熟悉吧？之前Angular里经常写

3    f1.BeginInvoke("回调函数", (ar) =>

4    {

5       var res = f1.EndInvoke(ar);

6        Console.WriteLine("通过回调函数取得结果: " + res);

7    },

8     null);

9

10

回调函数方式是最方便，最简洁的，用的也最多

2：通过Thread类启动线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1   //传入方法，即线程要执行的任务

2   //Thread t = new Thread(fun);

3

4   //或者直接Lambda表达式

5   Thread t = new Thread((s) =>

6   {

7   //可以获取线程ID

8       Console.WriteLine("线程：" + Thread.CurrentThread.ManagedThreadId + "开始执行任务");   

9       Thread.Sleep(3000);

10        Console.WriteLine("任务执行完毕,传递的参数是：" + s);

11    });

12

13    t.Start("Hello");//启动线程

14

15

这里就说一下前台线程和后台线程
后台线程就是主线程不会等待后台线程，当主线程执行完毕，如果有后台线程还在执行，那么后台线程会自动结束，而前台线程不会，只要有前台线程未结束，主线程就不会结束，会等待前台线程，默认Thread创建的线程都是前台线程，可以设置其属性isBackground
可以实验一下，设置t为后台进程，然后不加Console.ReadKey()，如果是前台进程就算不加，还是会等待进程执行的

线程的其他一些方法：

1
2
3
4
1   t.Abort();  //终止线程

2   t.Join();   //和C++里的一样，在Main中执行，会暂停Main线程，等待线程t执行完毕再执行Main线程

3

4

3：线程池（ThreadPool类）

创建一个个的线程需要花费很多时间，可以事先创建好线程，然后再要用的时候发出请求。这些线程就构成了线程池。
系统有一个ThreadPool类管理线程，线程池中创建的线程默认都是后台线程，默认Thread创建的线程都是前台线程。
ThreadPool的QueueUserWorkItem方法可以创建很多线程，传入的方法必须要有一个Object类型的参数

1
2
3
4
5
6
7
8
1   static void fun(object o)

2    {

3       Console.WriteLine("线程：" + Thread.CurrentContext.ContextID + "开始执行");

4        Thread.Sleep(3000);

5        Console.WriteLine("执行完毕");

6    }

7

8

Main中：

1
2
3
4
5
6
1//开启工作线程并加入到队列中，此方法在有线程池线程变得可用时执行

2          ThreadPool.QueueUserWorkItem(fun);

3          ThreadPool.QueueUserWorkItem(fun);

4          ThreadPool.QueueUserWorkItem(fun);

5

6

注意事项：
不能将入池的线程设为前台线程，不能修改线程池中线程的优先级、名字等，这些线程只能用于耗时比较短的小任务，主线程结束所有后台线程就结束，如果线程要一直运行，用Thread创建

4：任务（Task类，了解即可）
线程是没有父子关系的，平常说的子线程是为了便于理解，比如一个进程有多个线程，即一个主线程Main和其他子线程t1,t2,t3…
这些线程都是同级的，但是任务可以有父子关系，比如task1里启动task2，那么task2就是task1的子任务，两个任务异步执行。如果task1执行完了但是task2还没有，此时task1会等待task2执行完毕，task1状态变为WaitingForChildrenToComplete，task2执行完了， task1的状态就会变为RunToComplete
通过Task创建线程和Thread很像
1）new Task

1
2
3
4
1   Task t = new Task(fun);

2    t.Start();

3

4

2）TaskFactory

1
2
3
4
1   TaskFactory tf = new TaskFactory();

2    Task t1 = tf.StartNew(fun);

3

4

连续任务
比如任务t1要执行的话，依赖于任务2，需要任务2执行完毕才能执行任务1，那么这时候就要用到连续任务

5：线程问题：争用条件和死锁

如果多个线程启动，在某个同一时刻有两个以上线程同时访问资源，就会出现争用，为了让每个线程在访问资源时，根据此刻资源是否被访问来决定是访问资源还是等待，可以加锁，首先演示不加锁的情况下出现的问题：
定义一个类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1class MyThread

2{

3   private int data = 0;

4

5   public void setData()

6    {

7     //顺序执行的情况下是不可能输出"data=1"的

8      data++;

9      if (data == 1)

10      {

11          Console.WriteLine("data=1");

12      }

13          data = 0;

14      }

15    }

16

17

然后定义一个方法，不断去执行myClass的setData方法

1
2
3
4
5
6
7
8
9
10
11
1//该方法不断访问MyThread对象的setData方法

2   static void fun(object o)//传递给Thread的方法，要么没有参数，要么只有一个object类型的参数

3    {

4       var m = o as MyThread;

5        while(true)

6       {

7            m.setData();

8        |

9    }

10

11

然后让两个线程去执行fun

1
2
3
4
5
6
7
1   MyThread m = new MyThread();

2   Thread t = new Thread(fun);

3    t.Start(m);

4    Thread t1 = new Thread(fun);

5    t1.Start(m);

6

7

运行发现，输出data=0了
原因很简单
根本原因就是多个线程同时访问了资源，给资源加锁，就解决这个问题了

1
2
3
4
5
6
1lock (m)

2{

3    m.setData();

4}

5

6

当然实际问题复杂得多，这只是整理简单的知识，方便以后或者不太记得了，回头查查复习，整理知识用，实际中锁谁？锁整个类？程序粗粒度太大，虽然简单，但是并不高效