推荐几篇写的很好的文章，本文部分转自
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);
}
}