Thread,ThreadPool,Task (异步调用 async await )
程序中经常用到的同步和异步方法
同步：当一个方法被调用以后，调用者需等待该方法执行完毕以后方能再次调用
异步：当调用者调用一个方法时，会分配一个线程去处理方法内部业务逻辑，当在有其他调用者调用时，调用者不必等该方法执行是否完毕，就可调用
同步异步调用的应用场景
同步： 在需要执行方法需要立即出结果的，或者被调用者调用等结果返回值才能进行下一步操作的，都需要同步执行
异步：在不需要立即响应结果的，被执行的程序中基本没有关联的场景下。好处是非阻塞，因此可以把一些不需要立即使用结果，较耗时的任务设计为异步执行
可以提升程序运行效率。net4.0在ThreadPool的基础上推出了Task类，微软也极力推荐使用Task来执行异步任务，现在C#类库中的异步方法基本都用到了Task;
net5.0推出了async/await,让异步编程更为方便。
本文主要介绍Task、async\await相关内容
Task简介
Task是在ThreadPool的基础上推出的，ThreadPool中有若干数量的线程，如果有任务需要处理时，会从线程池中获取一个空闲的线程来执行任务，任务执行完毕线程不会被销毁，而是被线程池回收供后续任务使用。当线程池中所有的线程都在忙碌时。又有新的任务需要处理时，线程池才会新建一个线程来处理该任务。如果线程数量达到设置的最大值，任务会排队，等待其他任务释放线程后在执行。线程池能减少线程的创建，节省开销，举例说明ThreadPool
static void Main(string[] args) { ThreadPoolTest(); Console.ReadKey(); } public static void ThreadPoolTest() { for (int i = 0; i < 10; i++) { ThreadPool.QueueUserWorkItem(new WaitCallback((obj) => { Console.WriteLine($"第{obj}个执行任务"); }), i); } }
调用以后执行结果
从结果可以看出ThreadPool相对于Thread来说可以减少线程的创建，有效减少系统开销；但是ThreadPool不能控制线程的执行顺序，我们也不能获取线程池
内线程取消/异常/完成的通知，即我们不能有效监控和控制线程池中的线程，基于此我们来研究一下Task
Task创建和运行
net4.0在ThreadPool的基础上推出了Task，Task拥有线程池的优点，同时也解决了使用线程池不易控制的弊端
创建并运行Task，有三种方式方法：
static void Main(string[] args) { CreatTaskMethod(); Console.ReadKey(); }public static void CreatTaskMethod() { //方式一： Task task = new Task(()=> { Thread.Sleep(100); Console.WriteLine($"Task第一种创建方式：通过实例化一个Task,然后通过Start方法启动，当前线程Id为{Thread.CurrentThread.ManagedThreadId}"); }); task.Start(); //方式二： Task task2 = Task.Factory.StartNew(() => { Thread.Sleep(100); Console.WriteLine($"Task第二种创建方式：直接创建并启动Task，当前线程Id为{Thread.CurrentThread.ManagedThreadId}"); }); //方式三： Task task3 = Task.Run(()=> { Thread.Sleep(100); Console.WriteLine($"Task第三种创建方式：将任务放在线程池队列，返回并启动一个Task，当前线程Id为{Thread.CurrentThread.ManagedThreadId}"); }); Console.WriteLine("主线程创建"); }
执行结果如下：
可以看到线程的创建 并不影响主线程的创建，说明Task任务不会阻塞主线程，我们也可以创建带有返回值的Task<TResult>，创建方法和没有返回值的基本一样
代码如下：
static void Main(string[] args) { CreatTaskMethod(); Console.ReadKey(); } /// <summary> /// 创建带有返回值的Task任务 /// </summary> public static void CreatReturnTask() { //方式一： Task<string> task = new Task<string>(() => { return ($"Task第一种创建方式：通过实例化一个Task,然后通过Start方法启动，当前线程Id为{Thread.CurrentThread.ManagedThreadId}"); }); task.Start(); //方式二： Task<string> task2 = Task<string>.Factory.StartNew(() => { return ($"Task第二种创建方式：直接创建并启动Task，当前线程Id为{Thread.CurrentThread.ManagedThreadId}"); }); //方式三： Task<string> task3 = Task<string>.Run(() => { return ($"Task第三种创建方式：将任务放在线程池队列，返回并启动一个Task，当前线程Id为{Thread.CurrentThread.ManagedThreadId}"); }); Console.WriteLine("主线程创建"); Console.WriteLine(task.Result); Console.WriteLine(task2.Result); Console.WriteLine(task3.Result); }
执行结果：
注意: task.Result 获取结果时会阻塞线程，即如果task没有执行完成，会等待task执行完成以后获取结果Result,然后在执行后面的代码
可以把 Console.WriteLine("主线程创建"); 放到现在获取Result结果后面会的到
这里会发现主线程被阻塞了。
Task也可以同步执行，不会阻塞主线程。Task提供了 RunSynchronously()用于同步执行Task任务，代码如下：
public static void SyncTask() { for (int i = 0; i < 10; i++) { Task task = new Task(() => { Thread.Sleep(100); Console.WriteLine($"执行结果Task结束,当前执行顺序为{i}"); }); task.RunSynchronously(); } Console.WriteLine("主线程执行结束"); }
执行结果如下：
这里可以看到 Task执行线程是有顺序的，在使用RunSynchronously以后，会阻塞主线程，达到同步执行。除了使用RunSynchronously方法阻塞线程外，我们还可以使用（wait/waitAll/waitAny）阻塞Task
这里先说明一下Thread线程的阻塞方法
方法一：使用thread.join() 方法可以阻塞主线程 例：
static void Main(string[] args) { Thread th1 = new Thread(() => { Thread.Sleep(500); Console.WriteLine("线程1执行完毕！"); }); th1.Start(); Thread th2 = new Thread(() => { Thread.Sleep(1000); Console.WriteLine("线程2执行完毕！"); }); th2.Start(); //阻塞主线程 th1.Join(); th2.Join(); Console.WriteLine("主线程执行完毕！"); Console.ReadKey(); }
Task的Wait/WaitAny/WaitAll方法
Thread的join 方法可以阻塞调用线程，但弊端是不利于调用，如果需要阻塞的线程比较多，需要每个线程都要调用一次 Thread.join() 方法；
另外如果我们想要某一线程或者全部线程执行完毕以后，立即解除线程阻塞，使用 join不容易实现，而Task提供了这种机制，下面我们逐一解释一下
Wait() 表示等待Task执行完毕，功能类似于thread,join();
WaitAll(Task[] tasks) 表示只有所有的task都执行完毕以后在接触阻塞；
WaitAny(Task[] tasks) 表示只要有一个task执行完毕就解除阻塞。列：
public static void TaskWaitAll() { Task task = Task.Factory.StartNew(() => { Console.WriteLine("线程1执行完毕"); }); Task task1 = Task.Run(() => { Console.WriteLine("线程2执行完毕"); }); Task.WaitAll(new Task[] { task,task1 }); Console.WriteLine("主线程执行完毕!"); }
执行结果如下：
可以看到线程是异步执行在我们指定了WaitAll线程之后 主线程是出于阻塞状态的，当WaitAll下所有线程执行完毕以后，主线程才解除阻塞，执行,如果使用了
WaitAny 执行得到的结果就是 当线程一或者线程二任意一个执行完毕的时候 主线程就会解除阻塞，继续进行
注意：Wait 、WaitAll、WaitAny方法返回值都是void 这些方法单纯的实现阻塞线程。
如果想要让所有Task执行完毕，或则让任意Task执行完毕后，开始解除阻塞执行后续操作，该如何实现呢？这时候需要用到WhenAny、WhenAll方法了这些方法执行完毕以后会返回一个task实力。
Task中的延续操作（WhenAny/WhenAll/ContinueWith）
task.WhenAll(Task[] tasks) 表示所有的task都执行完毕以后再去执行后续的操作。
task.WhenAny(Task[] tasks)表示任意一个task执行完毕以后就开始后续操作。列：
static void Main(string[] args) { TaskWhenAll(); Console.ReadKey(); } /// <summary> /// WhenAll WhenAny /// </summary> public static void TaskWhenAll() { Task task1 = Task.Run(() => { Console.WriteLine("线程1执行完毕"); }); Task task2 = Task.Factory.StartNew(() => { Console.WriteLine("线程2执行完毕"); }); //Task.WhenAll(task1, task2).ContinueWith((t) => { // Console.WriteLine("执行后续操作"); //}); Task.WhenAny(task1, task2).ContinueWith((t) => { Console.WriteLine("任意线程执行完毕后执行"); }); Console.WriteLine("主线程执行完毕"); }
执行结果如下：
可以看到使用WhenAll、WhenAny时方法不会阻塞线程
上边的例子也可以通过Task.Factory.ContinueWhenAll(Task[] tasks,Action continuationAction) 和 Task.Factory.ContinueWhenAny(Task[] task, Action continuationAction)实现 例：
public static void TaskWhenAll() { Task task1 = Task.Run(() => { Console.WriteLine("线程1执行完毕"); }); Task task2 = Task.Factory.StartNew(() => { Console.WriteLine("线程2执行完毕"); }); //Task.WhenAll(task1, task2).ContinueWith((t) => { // Console.WriteLine("执行后续操作"); //}); //Task.WhenAny(task1, task2).ContinueWith((t) => { // Console.WriteLine("任意线程执行完毕后执行"); //}); Task task3 = Task.Factory.ContinueWhenAll(new Task[] { task1，task2}, (t) => { Console.WriteLine("线程全部执行完毕以后，执行"); }); Task task4 = Task.Factory.ContinueWhenAny(new Task[] { task1,task2 },(t)=> { Console.WriteLine("任意线程执行完毕以后，执行"); }); Console.WriteLine("主线程执行完毕"); }
这两种写法不同 但是功效是相同的
Task的任务取消
先看一下 Thread是如何取消任务执行的
1 设置变量来控制任务是否停止，如var isStop=false; 如果值为true 就停止代码如下
static void Main(string[] args) { bool isStop = false; int index = 0; //开启一个线程执行任务 Thread th1 = new Thread(() => { while (!isStop) { Thread.Sleep(1000); Console.WriteLine($"第{++index}次执行，线程运行中..."); } }); th1.Start(); //五秒后取消任务执行 Thread.Sleep(5000); isStop = true; Console.ReadKey(); }
Task是如何取消任务执行的呢？Task中有一个专门的类CancellationTokenSource 来取消任务执行，还是上面的例子，修改后如下：
/// <summary> /// 取消任务 /// </summary> public static void CancelTask() { CancellationTokenSource source = new CancellationTokenSource(); int index = 0; Task task = Task.Factory.StartNew(() => { while (!source.IsCancellationRequested) { Console.WriteLine($"第{++index}次执行,线程运行中......"); } }); //0.1秒后取消任务执行 //取消方法1： Thread.Sleep(100); source.Cancel();//这个时候IsChancellationRequested会变成true 还可以用 //取消方法2： //source.CancelAfter(100); //这个是0.1秒后自动取消的，和上面方法是等价的 }
了解了线程创建，执行，销毁，那么跨线程操作也是很有必要了解一下的
跨线程执行
public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void button1_Click(object sender, EventArgs e) { Task.Run(() => { Action<int> setValue = (p) => { textBox1.Text = p.ToString(); }; for (int i = 0; i < 1000000; i++) { textBox1.Invoke(setValue,i); } }); } }
异步方法（async/await)
在C#5.0中出现的，让异步编程变得更简单。我们看一个例子：
static void Main(string[] args) { MethodOne(); MethodTwo(); Console.ReadKey(); } public static async Task MethodOne() { await Task.Run(() => { for (int i = 0; i < 50; i++) {
Thread.Sleep(100); Console.WriteLine("111"); } }); } public static void MethodTwo() { for (int i = 0; i <30; i++) {
Thread.Sleep(100); Console.WriteLine("222"); } }
执行结果
可以看到虽然先调用了方法一 但是方法二 由于是异步 也没影响方法1的执行
