C#多线程

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

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

首先定义一个方法：

	static void fun(string s)
	{
		Console.WriteLine("fun："+s);
	}

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

	Action<string> a = fun;
	a.BeginInvoke("参数1",null,null);

	//Thread.Sleep(1000);
	Console.WriteLine("main");

看输出结果，是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里每隔一段时间就判断线程是否执行完毕，没有就输出“.”
线程执行完毕了就可以取得结果了：

	Func<string, string> f = fun1;
	var s = f.BeginInvoke("参数2", null, null);
	while (!s.IsCompleted)
	{
		Thread.Sleep(500);
		Console.Write(".");
    }
     Console.WriteLine();
     Console.WriteLine(f.EndInvoke(s));

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

	var isEnd = s.AsyncWaitHandle.WaitOne(3500);
    if (isEnd)
    {
         var res = f.EndInvoke(s);
         Console.WriteLine("通过等待句柄获取返回值：" + res);
    }
    else
    {
         Console.WriteLine("线程超时");
    }

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

	Func<string, string> f1 = fun1;
    //Lambda表达式熟悉吧？之前Angular里经常写
    f1.BeginInvoke("回调函数", (ar) =>
    {
    	var res = f1.EndInvoke(ar);
        Console.WriteLine("通过回调函数取得结果: " + res);
    },
     null);

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

2：通过Thread类启动线程

	//传入方法，即线程要执行的任务
	//Thread t = new Thread(fun);

	//或者直接Lambda表达式
	Thread t = new Thread((s) =>
	{
	//可以获取线程ID
		Console.WriteLine("线程：" + Thread.CurrentThread.ManagedThreadId + "开始执行任务");	
		Thread.Sleep(3000);
        Console.WriteLine("任务执行完毕,传递的参数是：" + s);
    });

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

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

线程的其他一些方法：

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

3：线程池（ThreadPool类）

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

	static void fun(object o)
    {
    	Console.WriteLine("线程：" + Thread.CurrentContext.ContextID + "开始执行");
        Thread.Sleep(3000);
        Console.WriteLine("执行完毕");
    }

Main中：

//开启工作线程并加入到队列中，此方法在有线程池线程变得可用时执行
          ThreadPool.QueueUserWorkItem(fun);
          ThreadPool.QueueUserWorkItem(fun);
          ThreadPool.QueueUserWorkItem(fun);

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

	Task t = new Task(fun);
    t.Start();

2）TaskFactory

	TaskFactory tf = new TaskFactory();
    Task t1 = tf.StartNew(fun);

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

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

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

class MyThread
{
	private int data = 0;

	public void setData()
    {
     //顺序执行的情况下是不可能输出"data=1"的
      data++;
      if (data == 1)
      {
      	Console.WriteLine("data=1");
      }
      	data = 0;
      }
    }

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

//该方法不断访问MyThread对象的setData方法
	static void fun(object o)//传递给Thread的方法，要么没有参数，要么只有一个object类型的参数
    {
     	var m = o as MyThread;
        while(true)
		{
        	 m.setData();
        |
    }

然后让两个线程去执行fun

	MyThread m = new MyThread();
	Thread t = new Thread(fun);
    t.Start(m);
    Thread t1 = new Thread(fun);
    t1.Start(m);

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

lock (m)
{
	 m.setData();
}

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