C# Task详解
推荐几篇写的很好的文章,本文部分转自
https://blog.csdn.net/btfireknight/article/details/97766193
https://blog.csdn.net/boonya/article/details/80541571
https://blog.csdn.net/nacl025/article/details/9163495/
1. Task 原理
这里简要的分析下CLR线程池,其实线程池中有一个叫做“全局队列”的概念,每一次我们使用QueueUserWorkItem的使用都会产生一个“工作项”,然后“工作项”进入“全局队列”进行排队,最后线程池中的的工作线程以FIFO(First Input First Output)的形式取出,这里值得一提的是在.net 4.0之后“全局队列”采用了无锁算法,相比以前版本锁定“全局队列”带来的性能瓶颈有了很大的改观。那么任务委托的线程池不光有“全局队列”,而且每一个工作线程都有”局部队列“。我们的第一反应肯定就是“局部队列“有什么好处呢?这里暂且不说,我们先来看一下线程池中的任务分配,如下图:
线程池的工作方式大致如下,线程池的最小线程数是6,线程1~3正在执行任务1~3,当有新的任务时,就会向线程池请求新的线程,线程池会将空闲线程分配出去,当线程不足时,线程池就会创建新的线程来执行任务,直到线程池达到最大线程数(线程池满)。总的来说,只有有任务就会分配一个线程去执行,当FIFO十分频繁时,会造成很大的线程管理开销。
下面我们来看一下task中是怎么做的,当我们new一个task的时候“工作项”就会进去”全局队列”,如果我们的task执行的非常快,那么“全局队列“就会FIFO的非常频繁,那么有什么办法缓解呢?当我们的task在嵌套的场景下,“局部队列”就要产生效果了,比如我们一个task里面有3个task,那么这3个task就会存在于“局部队列”中,如下图的任务一,里面有三个任务要执行,也就是产生了所谓的"局部队列",当任务三的线程执行完成时,就会从任务一种的队列中以FIFO的形式"窃取"任务执行,从而减少了线程管理的开销。这就相当于,有两个人,一个人干完了分配给自己的所有活,而另一个人却还有很多的活,闲的人应该接手点忙的人的活,一起快速完成。
从上面种种情况我们看到,这些分流和负载都是普通ThreadPool.QueueUserWorkItem所不能办到的,所以说在.net 4.0之后,我们尽可能的使用TPL,抛弃ThreadPool
2. Task细节
Task的属性IsCompleted, IsCanceled表示它是否完成和是否取消
具体的property参考官方API: https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.task?view=netcore-3.1
Async: 当一个方法由async关键字标识,表明这个方法是异步方法,当它被调用时,会创建一个线程来执行
Async 只能修饰void,Task,Task<>
(1) Task创建
static void Main(string[] args) { //1.new方式实例化一个Task,需要通过Start方法启动 Task task = new Task(() => { Thread.Sleep(100); Console.WriteLine($"hello, task1的线程ID为{Thread.CurrentThread.ManagedThreadId}"); }); task.Start(); //2.Task.Factory.StartNew(Action action)创建和启动一个Task Task task2 = Task.Factory.StartNew(() => { Thread.Sleep(100); Console.WriteLine($"hello, task2的线程ID为{ Thread.CurrentThread.ManagedThreadId}"); }); //3.Task.Run(Action action)将任务放在线程池队列,返回并启动一个Task Task task3 = Task.Run(() => { Thread.Sleep(100); Console.WriteLine($"hello, task3的线程ID为{ Thread.CurrentThread.ManagedThreadId}"); }); Console.WriteLine("执行主线程!"); Console.ReadKey(); }
(2) Task的取消以及取消回调方法
Task中有一个专门的类 CancellationTokenSource 来取消任务执行,CancellationTokenSource的功能不仅仅是取消任务执行,我们可以使用 source.CancelAfter(5000)
实现5秒后自动取消任务,也可以通过 source.Token.Register(Action action)
注册取消任务触发的回调函数,即任务被取消时注册的action会被执行。
static void Main(string[] args) { CancellationTokenSource source = new CancellationTokenSource(); //注册任务取消的事件 source.Token.Register(() => { Console.WriteLine("任务被取消后执行xx操作!"); }); int index = 0; //开启一个task执行任务 Task task1 = new Task(() => { while (!source.IsCancellationRequested) { Thread.Sleep(1000); Console.WriteLine($"第{++index}次执行,线程运行中..."); } }); task1.Start(); //延时取消,效果等同于Thread.Sleep(5000);source.Cancel(); source.CancelAfter(5000); Console.ReadKey(); }
查看结果
(3) 实例分析
static void Main(string[] args) { Console.WriteLine("111 balabala. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId); AsyncMethod(); SyncMethod(); Thread.Sleep(10000); Console.WriteLine("222 balabala. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId); } private static async Task AsyncMethod() { Console.WriteLine("Helo I am AsyncMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId); var ResultFromTimeConsumingMethod = TimeConsumingMethod(); string Result = await ResultFromTimeConsumingMethod + " + AsyncMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId; Console.WriteLine(Result); //返回值是Task的函数可以不用return } private static Task SyncMethod() { var task = Task.Run(() => { Console.WriteLine("Helo I am SyncMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId); Thread.Sleep(5000); Console.WriteLine("Helo I am SyncMethod after Sleep(5000). My Thread ID is :" + Thread.CurrentThread.ManagedThreadId); }); return task; } //这个函数就是一个耗时函数,可能是IO操作,也可能是cpu密集型工作。 private static Task<string> TimeConsumingMethod() { var task = Task.Run(() => { Console.WriteLine("Helo I am TimeConsumingMethod. My Thread ID is :" + Thread.CurrentThread.ManagedThreadId); Thread.Sleep(5000); Console.WriteLine("Helo I am TimeConsumingMethod after Sleep(5000). My Thread ID is :" + Thread.CurrentThread.ManagedThreadId); return "Hello I am TimeConsumingMethod"; }); return task; }
执行结果如下:
Main 函数里面增加Thread.Sleep(10000)是防止主线程结束,一旦主线程结束了,那么其他线程也释放了。
如图可以看出这几个关键字的真正含义
1. 当执行返回参数为Task或者Task<>类型的函数时,假如该函数没有用async标识,那么开启线程执行开方法
2. 当有async标识时,当前线程会把该方法当成同步函数执行,直到运行到await关键字的地方,开启新线程(此时假如中途执行另一个Task标识的方法,不管该方法是不是async,都会同步执行,不会开启新线程, 但是加入把一个task得方法放到变量中,会开启新的线程,这里非常重要。看如下代码)
public async Task Test() { await xxx; // 这里会在当前task得线程中执行RunOtherTask方法,并不会开启新的task RunOtherTask(); // 这里主线程会继续执行下面得代码,开启一个新的线程执行RunOtherTask _ = RunOtherTask(); await otherLogic } private Task RunOtherTask() { return Task.Run(() => { for (var i = 0; i < 100000; i++) { XXX } }); }
3. await关键字表示会开辟新线程来执行后面的方法,但是该线程会等待新线程执行完返回,然后继续执行
函数的执行途中是根据await关键字来判断是否需要开辟线程来执行代码(Async void方法调用时不能加await,所以它必定是在主线程中被调用),假如被调用的method前面有await,那么这个method必须包含async关键字,假如一个async标识的方法里面没有await,那么这个方法会被当成同步方法来调用
3. Task关键点
Async void 主要用于异步事件处理方法,其他时候请不要使用,在async void方法中,一定要加try catch来捕捉异常。
Async void 方法具有不同的错误处理语义。 当 async Task 或 async Task<T> 方法引发异常时,会捕获该异常并将其置于 Task 对象上。 对于 async void 方法,没有 Task 对象,因此 async void 方法引发的任何异常都会直接在 SynchronizationContext(在 async void 方法启动时处于活动状态)上引发。 无法捕获从 async void 方法引发的异常。所以对于Async void方法必须加入try/catch。
Async void 方法具有不同的组合语义。 返回 Task 或 Task<T> 的 async 方法可以使用 await、Task.WhenAny、Task.WhenAll 等方便地组合而成。 返回 void 的 async 方法未提供一种简单方式,用于向调用代码通知它们已完成。 启动几个 async void 方法不难,但是确定它们何时结束却不易。 Async void 方法会在启动和结束时通知 SynchronizationContext,但是对于常规应用程序代码而言,自定义 SynchronizationContext 是一种复杂的解决方案。
Async void 方法难以测试。 由于错误处理和组合方面的差异,因此调用 async void 方法的单元测试不易编写。 MSTest 异步测试支持仅适用于返回 Task 或 Task<T> 的 async 方法。 可以安装 SynchronizationContext 来检测所有 async void 方法都已完成的时间并收集所有异常,不过只需使 async void 方法改为返回 Task,这会简单得多。推荐使用下面方法实现
private async void button1_Click(object sender, EventArgs e)
{
await Button1ClickAsync();
}
public async Task Button1ClickAsync()
{
// Do asynchronous work.
await Task.Delay(1000);
}
应避免混合使用异步代码和阻塞代码。 混合异步代码和阻塞代码可能会导致死锁、更复杂的错误处理及上下文线程的意外阻塞,推荐除了main方法外都使用async方法,不要再异步代码使用Task.Result和Task.Wait。并且推荐使用ConfigureAwait(false)。
还没有完全理解内部的原理,请看下面的链接
https://blog.csdn.net/WPwalter/article/details/79673214
http://blog.walterlv.com/post/deadlock-in-task-wait.html
4. async和Lambda
async Action == async void
async Func<string> == async Task<string>
当一个Action或者Func的类型是async void,并且作为参数传递到另一个方法中,当执行另一个方法时,并不能等待Action执行完再继续
看代码
public Task ExecuteAction(Action action) { Console.WriteLine("In ExecuteAction = " + Thread.CurrentThread.ManagedThreadId); action(); Console.WriteLine("In ExecuteAction = " + Thread.CurrentThread.ManagedThreadId); TestAsync(); Console.WriteLine("In ExecuteAction = " + Thread.CurrentThread.ManagedThreadId); return Task.CompletedTask; } public async Task ExecuteAwaitAction(Action action) { Console.WriteLine("In ExecuteAwaitAction = " + Thread.CurrentThread.ManagedThreadId); await Task.Run(action); await TestAsync(); } private static void Main(string[] args) { try { Console.WriteLine("In main = " + Thread.CurrentThread.ManagedThreadId); Test(); } catch (Exception e) { Console.WriteLine(e); throw; } Console.ReadKey(); } private async Task TestAsync() { Console.WriteLine("In Delay = " + Thread.CurrentThread.ManagedThreadId); await Task.Delay(3000); Console.WriteLine("In Delay = " + Thread.CurrentThread.ManagedThreadId); } public static async void Test() { Console.WriteLine("In Test = " + Thread.CurrentThread.ManagedThreadId); IActionTest actionTest = new ActionTest(); await actionTest.ExecuteAction( TestAwait); //await actionTest.ExecuteAwaitAction( () => //{ // TestAwait(); //}); var a = 1; } public static async void TestAwait() { Console.WriteLine("In TestAwait = " + Thread.CurrentThread.ManagedThreadId); await Testsss(); int a = 3; a++; } public static async Task Testsss() { Console.WriteLine("In Testsss = " + Thread.CurrentThread.ManagedThreadId); await Task.Run(() => { Console.WriteLine("In lambda = " + Thread.CurrentThread.ManagedThreadId); int ctr = 0; for (ctr = 0; ctr <= 1000000000; ctr++) { } Console.WriteLine("Finished {0} loop iterations", ctr); }); //下面的方法会将其当成void方法 //int ctr = 0; //for (ctr = 0; ctr <= 1000000000; ctr++) //{ } //Console.WriteLine("Finished {0} loop iterations", // ctr); }
最后的结果是不管是在ExecutAction还是ExecutAwaitAction里面,action方法都不会等待,会直接执行下面的test方法,因为action本身就是异步方法,而在实现ExecutAction不能实现await Action,所以会立即返回。写代码时要注意当需要使用Func的返回值时,这种形式是有问题的。
5. 判断Task超时的方法
用Task.Delay(ElapsedMilliseconds, _cancellationTokenSource.Token);而不用Task.Delay(ElapsedMilliseconds); 因为后者会卡住task固定的时常,但是用前者可以随时取消。
/// <summary> /// Gets another task which that the given task <paramref name="self"/> can be awaited with a <paramref name="timeout"/>. /// </summary> /// <param name="self">The task to be awaited.</param> /// <param name="timeout">The number of milliseconds to wait.</param> /// <returns> /// <c>true</c> if the <see cref="Task"/> completed execution within the allotted time; otherwise, <c>false</c>. /// </returns> public static async Task<bool> GetTaskWithTimeout(this Task self, int timeout) { var timeoutTask = Task.Delay(timeout); var finishedTask = await Task.WhenAny(self, timeoutTask); // If the returned task is the return ReferenceEquals(finishedTask, self); }
6. 使用CancellationTokenSource创建一个定时轮询的service, 本机测试的是每小时查询一次电压,假如过低就记录日志,并且只记录一次
private const int ElapsedMilliseconds = 3600000;private const int StopTaskTimeout = 2000; private bool _isBatteryLowShown; private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();private Task _checkingStatusTask; /// <summary> /// Starts the service. /// </summary> public Task StartAsync() { _isBatteryLowShown = false; _checkingStatusTask = RunCheckBatteryStatusPeriodicTask(); return Task.CompletedTask; } /// <summary> /// Stops the service. /// </summary> public async Task StopAsync() { _cancellationTokenSource.Cancel(); await _checkingStatusTask.GetTaskWithTimeout(StopTaskTimeout); if (!_checkingStatusTask.IsCompleted) { _logger.Warning($"Failed to stop checking status task within {StopTaskTimeout} ms - stopping anyway."); } } private async Task RunCheckBatteryStatusPeriodicTask() { try { while (!_cancellationTokenSource.IsCancellationRequested) { var status = xxx(); if (status && !_isBatteryLowShown) { _isBatteryLowShown = true; _logger.Error("Battery is low."); } await Task.Delay(ElapsedMilliseconds, _cancellationTokenSource.Token); } } catch (Exception e) { _logger.ErrorEx(message: $"{nameof(_checkingStatusTask)} exception.", sourceType: nameof(BatteryMonitoringService), ex: e); } }