多线程和异步
异步方法—Async、Await
一:前言
1.所有带有Async关键字的异步方法返回类型:
① Task<T>:如果调用方法想通过调用异步方法获取一个T类型的返回值,那么签名必须为Task<TResult>;
② Task:如果调用方法不想通过异步方法获取一个值,仅仅想追踪异步方法的执行状态,那么我们可以设置异步方法签名的返回值为Task;
③ void:如果调用方法仅仅只是调用一下异步方法,不和异步方法做其他交互,我们可以设置异步方法签名的返回值为void,这种形式也叫做“调用;
即:异步方法的返回值类型必须为Task或Task<T>;
2.异步方法的“传染性“:一个方法中如果有await调用,则这个方法也必须修饰为async。
3.在async方法中遇到await关键字后,当前线程立即返回(到调用方),继续之前的处理逻辑;await关键字之后的代码逻辑,将交由新的线程处理;当新的线程处理完成后,可以从新的线程返回处理结果到调用(处)线程当中,结束等待。
4.在一个async方法中,会根据await关键字进行分割,拆分到不同的线程处理同一个方法的不同部分!如下例:
![复制代码](https://common.cnblogs.com/images/copycode.gif)
static void Main(string[] args) { Console.WriteLine("{0}->Main.异步方法执行前", Thread.CurrentThread.ManagedThreadId.ToString());//输出异步处理之前的线程ID DoAsync(1000).Wait();//执行异步处理,并等待该异步方法执行完成后才继续 Console.WriteLine("{0}->Main.异步方法执行后", Thread.CurrentThread.ManagedThreadId.ToString());//输出异步处理之后的线程ID Console.Read(); } /// <summary> /// 执行异步处理 /// </summary> /// <param name="times">模拟处理时长</param> /// <returns></returns> public static async Task DoAsync(int times) { Console.WriteLine("{0}->DoAsync.await之前", Thread.CurrentThread.ManagedThreadId.ToString());//输出调用线程ID await Task.Run(() => Thread.Sleep(times));///执行一个异步任务,并等待返回结果才继续;需要注意的是,调用线程执行到这一行的时候其实就已经返回了 Console.WriteLine("{0}->DoAsync.await之后", Thread.CurrentThread.ManagedThreadId.ToString());//异步操作执行完了,但这里已经是新的线程了 }
![复制代码](https://common.cnblogs.com/images/copycode.gif)
运行结果:
请注意:在同步方法Main中执行的时候都是同一个线程;在异步方法DoAsync执行的时候,在await之前是调用线程,在await之后则是另一个线程。
5.把一个方法代码的不同部分拆分到多个线程处理,这是异步方法和同步方法的最大不同!
总而言之:
在异步(async)方法执行中,会根据await关键字,拆分一个方法为多个部分,分别由不同的线程执行。
在异步(async)方法执行中,遇到await关键字,调用线程会立即返回(线程池)继续后续的处理逻辑;而后,调用方可以使用Task.Wait()或Task<T>.Result进行阻塞,等待异步方法执行完毕再继续。
在异步(async)方法执行后,若不使用Task.Wait()进行等待,或不使用Task<T>.Result获取返回结果,则该方法将仅以异步方式执行。
二:详解Async和await关键字
1.Async和await细节
async和await可以创建和使用异步方法,这个特性的由三个部分组成:
①调用方法(calling method):该方法调用异步方法,然后在异步方法(可能使用同一个线程也可能不在一个线程)执行其任务的时候继续执行
②异步方法(async): 该方法异步执行其工作,然后立即方法到调用方法
③await表达式:用于异步方法内部,指明需要异步执行的惹怒我。一个异步方法可以包含任意多个await表达式,如果一个都不包含编译器会发出警告
![复制代码](https://common.cnblogs.com/images/copycode.gif)
//1.调用方法 static void Main(string[] args) { Task<int> t = DoSumAsync(1, 2); Console.WriteLine("结果:{0}", t.Result); Console.ReadKey(); } //2.异步方法 public static async Task<int> DoSumAsync(int a, int b) { //3.await 表达式 int sum = await Task.Run(() => { return a + b; }); return sum; }
![复制代码](https://common.cnblogs.com/images/copycode.gif)
2.什么是异步?
异步方法在完成其工作之前返回到调用方法,并在调用方法继续执行的时候完成其工作。语法上有如下特征:
① 方法使用async作为修饰符
② 方法内部包含一个或者多个await表达式,表示可以异步完成的任务
③ 必须具备以下三种返回类型 void 、Task 、Task<T> ,其中后两种的返回对象标识讲座未来完成的工作,调用方法和异步方法可以继续执行。
④异步方法的参数可以任意类型,但是不能为out和ref参数
⑤约定俗成,一般异步方法都是以 Async作为后缀的。
⑥ 除了方法之外,Lambda表达式和匿名函数也可以作为异步对象。
![复制代码](https://common.cnblogs.com/images/copycode.gif)
private async Task<int> CountCharactersAsync(int id, string uriString) { WebClient wc = new WebClient(); Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds); string result = await wc.DownloadStringTaskAsync(new Uri(uriString)); Trace.TraceInformation("Taceing Async Call {0} @time:{1:N0}ms", id, sw.Elapsed.TotalMilliseconds); Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds); return result.Length; }
![复制代码](https://common.cnblogs.com/images/copycode.gif)
详细说明:
①async关键字是一个上下文关键字,也就是说除了做为方法(lambda和匿名函数)的修饰符之外,还可以做标识符。
②返回类型
Task类型:如果调用方法不需要从异步方法中返回某个值,但需要检查异步方法的状态,可以返回一个Task,此时就算异步方法中出现了return语句,也不会返回任何东西。
Task<T>类型,除了上面Task的功能,还可以通过 Return属性来获取返回的T类型的值。
void类型:如果仅仅是执行异步方法,而不需要与它做任何进一步的交互(“调用并忘记”),此时可以用void,和Task一样,就算有return语句,也得不到任何东西。
3.异步方法的控制流
首先要明确“异步方法”的三个部分,如下图所示:
①首先是第一个await之前的部分,这部分应该是少量且无需长时间等待的代码。
②await表达式,表示需要被异步执行的任务,这里有两个await表达式,第二个await和之前的同步部分和第一个await以及之前的部分是一样的。
③后续部分:在await表达式之后出现的方法中的其余代码。
执行过程:
有几个注意的地方:
① await之前的部分是同步执行的
② 当达到awati的时候,会将异步方法的控制返回给调用方法。如果方法返回的类型是Task或者Task<T>,将创建一个Task对象,表示需异步完成的任务和后续,然后将该Task返回到调用方法。 这里的返回值并不是await表达式的返回值,而是异步方法中声明的返回值类型。
③ 异步方法内部需要完成以下工作:
- 异步执行await表达是的空闲任务
- 当await表达式执行完成之后,执行后续部分。后续本身也可能是await表达式,处理过程和上一个一致。
- 后续部分如果遇到 return 或者 方法达到末尾,将做如下的事情:
l 如果返回的类型是void,控制流就退出了
l 如果返回的类型是Task,后续部分设置Task对象的属性并退出。
l 如果返回的类型是Task<T>,不仅要设置Task对象属性,还要设置Task对象的Return属性。
这个点要注意下:并不是遇到return或者达到方法末尾,就能获取到返回值,它只是退出了。
④ 调用方法继续执行,会从异步方法获取Task对象。当需要其实际值的时候,就引用Task对象中的Result属性。届时,如果异步方法设置了该属性,调用方法获取其值并继续。否则就等待该属性被设置,然后再继续执行。
4.await表达式
await表达式指定了一个异步执行的任务。语法由 await关键字 + 一个空闲对象(称为任务)组成。这个任务可能是一个Task对象,也可以不是,默认情况下由该线程异步执行。
一个空闲对象 指的是一个awaitable类型的实例,awaitable类型是指包含了GetAwaiter方法的类型,方法没有参数,返回一个称为awaiter类型的对象。
一个awaiter对象包含了如下成员:
一般情况下我们不需要自己构建一个awaiter对象,使用.net 自己的Task就可以了。最简单的方法就是使用Task.Run()来返回一个Task对象。关于Task.Run()有一个非常重要的点,他将在不同的线程上运行你的方法。
5.异常处理和await表达式
![复制代码](https://common.cnblogs.com/images/copycode.gif)
static void Main(string[] args) { Task t = BadAsync(); t.Wait(); Console.WriteLine("Task Status: {0}", t.Status ); Console.WriteLine("Task IsFaulted: {0}", t.IsFaulted ); Console.WriteLine("Please enter a key to exit!"); Console.ReadKey(); } static async Task BadAsync() { try { await Task.Run(() => { throw new Exception(); }); } catch { Console.WriteLine("Exception in BadAsync"); } }
![复制代码](https://common.cnblogs.com/images/copycode.gif)
运行结果:
从结果可以看到,虽然在异步方法内部进行了try..catch,并且也catch到了异常,但是对于调用函数,返回的Task状态依然为 RanToCompletion 。
为什么这个亚子?,原因如下:
① Task没有被取消掉
② 没有未处理的异常。类似的IsFaulted是false。
6.在调用方法中同步的等待任务(WaitAll、WaitAny)
对于单个Task,可以通过task对象的wait方法等待:
Task<int> t = CountCharactersAsync("http://www.163.com"); t.Wait();
对于多个Task,可以使用WaitAll()或者WaitAny()方法,进行同步:
Task<int> t1 = CountCharactersAsync(1, "http://www.163.com"); Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com"); Task<int>[] tasks = new Task<int>[] { t1, t2 }; Task.WaitAll(tasks);
WaitAny是只要一个完成就可以继续操作:
Task<int> t1 = CountCharactersAsync(1, "http://www.163.com"); Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com"); Task<int>[] tasks = new Task<int>[] { t1, t2 }; Task.WaitAny(tasks);
7.在异步方法中异步的等待任务 (WhenAll、.WhenAny)
上面说明了如何在“调用方法”中,同步等待Task的完成。 但是有时候,我们在一个异步方法中也会存在多个任务,想要让它们通过await表达式等待。我们可以通过Task.WhenAll() 和 Task.WhenAny() 方法实现。 这两个方法称为组合子(combinator)。
![复制代码](https://common.cnblogs.com/images/copycode.gif)
private async Task<int> CountCharactersAsync(string site1, string site2) { WebClient wc1 = new WebClient(); WebClient wc2 = new WebClient(); Task<string> t1 = wc1.DownloadStringTaskAsync(new Uri(site1)); Task<string> t2 = wc2.DownloadStringTaskAsync(new Uri(site2)); List<Task<string>> tasks = new List<Task<string>>(); tasks.Add(t1); tasks.Add(t2); //组合子 await Task.WhenAll(tasks); //await Task.WhenAny(tasks); Console.WriteLine(" CCA: T1 {0} Finished", t1.IsCompleted ? "" : "Not"); Console.WriteLine(" CCA: T2 {0} Finished", t2.IsCompleted ? "" : "Not"); return t1.IsCompleted? t1.Result.Length: t2.Result.Length; }
![复制代码](https://common.cnblogs.com/images/copycode.gif)
8.使用Task.Delay暂停线程处理
一般我们都使用Thread.Sleep(xxxx) 进行线程的延时,但是 Thread.Sleep会阻塞线程。而Task.Delay则不会阻塞线程,线程可以继续处理其他的工作。
![复制代码](https://common.cnblogs.com/images/copycode.gif)
class Simple { Stopwatch sw = new Stopwatch(); public void DoRun() { Console.WriteLine("Caller: Before call"); ShowDelayAsync(); Console.WriteLine("Caller: After call"); } private async void ShowDelayAsync() { sw.Start(); Console.WriteLine(" Before Delay: {0} ", sw.Elapsed.Milliseconds ); await Task.Delay(1000); Console.WriteLine(" After Delay: {0} ", sw.Elapsed.Milliseconds); } }
![复制代码](https://common.cnblogs.com/images/copycode.gif)
C#关于在返回值为Task方法中使用Thread.Sleep引发的思考
起因
最近有个小伙伴提出了一个问题,就是在使用.net core的BackgroundService的时候,对应的ExecuteAsync方法里面写如下代码,会使程序一直卡在当前方法,不会继续执行,代码如下:
复制代码- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
public class BGService : BackgroundService
{
protected override Task ExecuteAsync(CancellationToken stoppingToken)
{
while (true)
{
Thread.Sleep(1000);
}
}
}
其实这个问题我们还是对Task和异步执行过程理解不够深入导致的,所以本篇文章笔者就以这个问题来对Task和异步方法执行过程来做源码的探究。
PS:本文只贴出重要的代码和注释,不是其全部的代码,读者多关注下注释。
解析
Thread.Sleep和Task.Delay的区别
- Thread.Sleep分析
它会挂起当前执行线程指定时间(调用了系统内核的方法),而这时候当前线程是不能做任何其他的事情,只能等待指定时间后再执行。最终执行的代码如下图:
- 1
- 2
- 3
- 4
- 5
private static void SleepInternal(int millisecondsTimeout)
{
//这是Windows平台,不同平台调用的方法不一样
Interop.Kernel32.Sleep((uint)millisecondsTimeout);
}
- Task.Delay分析
它的执行实际上是交给了TimerQueueTimer,也就是定时器队列(每个进程里,所有的timer执行都在一个TimerQueueTimer队列集合里面),在指定时间后回调方法,由ThreadPool中的线程执行。实际执行代码如下图:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
public static Task Delay(int millisecondsDelay, CancellationToken cancellationToken)
{
if (millisecondsDelay < -1)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.millisecondsDelay, ExceptionResource.Task_Delay_InvalidMillisecondsDelay);
}
//开始执行Delay方法
return Delay((uint)millisecondsDelay, cancellationToken);
}
private static Task Delay(uint millisecondsDelay, CancellationToken cancellationToken) =>
cancellationToken.IsCancellationRequested ? FromCanceled(cancellationToken) :
millisecondsDelay == 0 ? CompletedTask :
//它继承自DelayPromise,只不过加了CancellationToken
cancellationToken.CanBeCanceled ? new DelayPromiseWithCancellation(millisecondsDelay, cancellationToken) :
//最终执行这个
new DelayPromise(millisecondsDelay);
internal DelayPromise(uint millisecondsDelay)
{
if (millisecondsDelay != Timeout.UnsignedInfinite)
{
//把任务放到定时队列里
_timer = new TimerQueueTimer(s_timerCallback, this, millisecondsDelay, Timeout.UnsignedInfinite, flowExecutionContext: false);
//如果已经完成了,就把这个销毁掉
if (IsCompleted)
{
_timer.Close();
}
}
}
总结来说:
1.Thread.Sleep会让当前执行线程挂起一段时间,而在挂起的过程中,不能去干其他的事情,影响线程池对线程的调度,间接影响系统的并发性。
2.Task.Delay由创建定时队列消息,在指定时间之后由线程池去处理Callback,而在这指定时间内是由系统去调度的(这里可能我理解不对),而当前执行线程可以继续干其他事情。
多线程和异步
Task任务默认情况下是通过线程池中的空闲线程去执行,除非设置LongRunning才会单独开启一个Thread去执行。一般来说多线程只是异步编程实现的一种方式,
- 多线程
并行的处理一些任务,尤其是多核CPU,充分利用CPU的性能,增加任务的处理效率,如Paraller并行库等。 - 异步
IO密集型操作:如Web应用在进行数据库操作,文件操作或者调用外部接口,发生磁盘IO或者网络IO时,如果非异步操作,会使当前执行线程一直保持等待事件的完成,而不做其他的处理,导致资源被浪费。如果是异步操作,当前执行线程在出发IO操作后,线程不需要等待事件的完成再去操作,而可以由线程池调度执行其他的请求,那么当事件完成后,由操作系统硬件去通知,然后再有线程池去调度线程去执行。所以我们可以发现在执行异步方法时,await前和await后不一定是相同一个线程去执行,可能会切换线程(可以对比前后的线程Id)。
CPU密集型操作:如进行大量的计算任务,需要CPU一直调度,我们在WinForm或者WPF中可能会有很深的体会。假如我们执行一个很复杂的计算任务,如果是同步的话,用户得一直等待计算完成,UI才会展示,如果是异步的话,用户不用等待计算完成,UI直接就正常显示和操作,而这部分计算由线程池提供的线程独立其执行,而不影响当前执行线程的操作。
Async和Await
一般来说我们使用Await和Async是一起使用的,但是它存在其传播性,它本身实际上是个语法糖,算是隐性的调用ContinueWith方法,在执行完成后继续执行其他任务,接下我们来解析下他是怎么执行的。我们看下如下代码:
复制代码- 1
- 2
- 3
- 4
public async Task AA() {
await Task.Delay(1000);
Console.WriteLine("执行到我了");
}
实际上上面的代码在编译之后,会形成一个状态机(只有标识是async的才会被编译成状态机的形式),具体代码如下(含注释),
复制代码- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
public class C
{
[StructLayout(LayoutKind.Auto)]
[CompilerGenerated]
private struct <AA>d__0 : IAsyncStateMachine //所有的异步方法都继承自它
{
//初始值是-1
public int <>1__state;
//异步任务方法构造器
public AsyncTaskMethodBuilder <>t__builder;
private TaskAwaiter <>u__1;
private void MoveNext()
{
int num = <>1__state;
try
{
TaskAwaiter awaiter;
if (num != 0)
{
//在有标识await的地方,会调用对应Task的GetAwaiter()方法,但是它还是会以当前执行线程去调用Task.Delay。
awaiter = Task.Delay(1000).GetAwaiter();
//当await是未完成状态
if (!awaiter.IsCompleted)
{
num = (<>1__state = 0);
<>u__1 = awaiter;
//重点是这个方法,里面实际上是执行了ContinueWith,而在Task执行完成之后,又调用其MoveNext方法(这时候可能是不同的线程去执行的)。
<>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
return;
}
}
else
{
awaiter = <>u__1;
<>u__1 = default(TaskAwaiter);
num = (<>1__state = -1);
}
awaiter.GetResult();
//在获取到值之后,继续执行await后面的代码
Console.WriteLine("执行到我了");
}
catch (Exception exception)
{
<>1__state = -2;
<>t__builder.SetException(exception);
return;
}
<>1__state = -2;
<>t__builder.SetResult();
}
void IAsyncStateMachine.MoveNext()
{
this.MoveNext();
}
}
//AA整个异步方法被编译成这样
[AsyncStateMachine(typeof(<AA>d__0))]
public Task AA()
{
//构建状态机
<AA>d__0 stateMachine = default(<AA>d__0);
//创建异步任务方法构造器
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>1__state = -1;
//执行Start方法
stateMachine.<>t__builder.Start(ref stateMachine);
//返回当前Task
return stateMachine.<>t__builder.Task;
}
}
我们来看AA异步方法,被编译成一个完全不同的方法,在d__0中有一个MoveNext方法,来执行Task和原来await后面的代码。
AA方法中stateMachine.<>t__builder.Start(ref stateMachine);我们看一下到底执行了什么,如下:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
public struct AsyncTaskMethodBuilder<TResult>
{
[DebuggerStepThrough]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine =>
AsyncMethodBuilderCore.Start(ref stateMachine);
}
internal static class AsyncMethodBuilderCore
{
[DebuggerStepThrough]
public static void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
{
if (stateMachine == null) // TStateMachines are generally non-nullable value types, so this check will be elided
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stateMachine);
}
Thread currentThread = Thread.CurrentThread;
//当前线程的执行上下文
ExecutionContext? previousExecutionCtx = currentThread._executionContext;
//当前线程的同步上下文
SynchronizationContext? previousSyncCtx = currentThread._synchronizationContext;
try
{
//这里当前执行线程开始执行状态机的MoveNext方法
stateMachine.MoveNext();
}
finally
{
//此处省略,主要是防止上下文改变,设置上下文。
}
}
}
在MoveNext方法里面,我们继续看,如果当前Task的状态是未完成的话,那么会执行一个叫做AwaitUnsafeOnCompleted的方法,我们看如下代码:
复制代码- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
public struct AsyncTaskMethodBuilder<TResult>
{
[MethodImpl(MethodImplOptions.AggressiveOptimization)]
internal static void AwaitUnsafeOnCompleted<TAwaiter>(
ref TAwaiter awaiter, IAsyncStateMachineBox box)
where TAwaiter : ICriticalNotifyCompletion
{
//一般来说当前await是TaskAwaiter继承自ITaskAwaiter,所以会计入这个判断
if ((null != (object?)default(TAwaiter)) && (awaiter is ITaskAwaiter))
{
ref TaskAwaiter ta = ref Unsafe.As<TAwaiter, TaskAwaiter>(ref awaiter);
//这个box,里面包含MoveNext方法。
TaskAwaiter.UnsafeOnCompletedInternal(ta.m_task, box, continueOnCapturedContext: true);
}
//省略部分代码。。。
}
}
public readonly struct TaskAwaiter : ICriticalNotifyCompletion, ITaskAwaiter
{
internal static void UnsafeOnCompletedInternal(Task task, IAsyncStateMachineBox stateMachineBox, bool continueOnCapturedContext)
{
Debug.Assert(stateMachineBox != null);
//这里省略了if判断
else
{
//执行当前TaskContinuationForAwait,也就类似ContinuWith,当前的task的ContinuWith就是执行MoveNext方法
task.UnsafeSetContinuationForAwait(stateMachineBox, continueOnCapturedContext);
}
}
}
总结来说:
1.带有Async的异步方法会在编译之后生成状态机。
2.当前执行线程会一直执行,把对应的MoveNext放到task的Continuation里面,也就是当作task完成的延续任务(回调事件)。
3.当前线程不是在执行异步任务的时候切换线程,而是一直执行方法内部,直到内部方法执行完成,所以我们在编写自定义的Task方法时,应该保证该方法能够进行立即的返回Task,不要执行过多的其他事情。
4.当发生线程切换时(也可能不切换),其实是看线程池的调度,让哪个线程去执行对应的Callback(MoveNext方法),所以我们有时候在调试时可以发现在await前和await之后其实可能不是一个线程id。
5.其实我们想一下WinForm和WPF的应用使用异步编写,其实当前执行线程已经返回了Task(异步方法编译后,是直接返回Task),也就是说执行完了,所以没有造成阻塞,而后来UI上的还能显示对应的元素,是因为任务调度完成,由其他线程去执行了这个操作,而这个线程保持了执行上下文和同步上下文。
结果
1.从上述解析可以看出,当在BackgroundService中直接在While循环里面写Thread.Sleep,当前执行线程会一直执行这段代码,也就是卡到这个while了,具体到编译后的代码就是卡到stateMachine.<>t__builder.Start(ref stateMachine),然后不会再继续往下执行了。
2.当我们使用async和await之后,并将Thread.Sleep替换为Task.Delay之后,当前方法就被编译成状态机,在当前线程执行到awaiter = Task.Delay(1000).GetAwaiter()之后,把当前MoveNext添加到这个Task的Continution,然后直接返回了Task,这样并不会阻塞当前线程继续往下执行,而后面的事情交给线程池空闲线程去执行。
3.如果我们不使用async和await的话,那么我们可以启动一个Task.Run(建议将TaskCreationOptions设置为LongRunning),这样的话该方法直接返回了Task,也不会阻塞当前线程继续往下执行。
4.对于Thread.Sleep在异步编程中不建议使用,建议使用Task.Delay,这样线程能够被更有效的利用起来。
以上就是笔者的看法,因为篇幅问题,没有贴太多的代码,有兴趣的小伙伴可以去看看源码就了解了,总结的可能会有一些理解错误的地方,还请评论指正。
本文作者:SnailZz
本文链接:https://www.cnblogs.com/snailZz/p/16198199.html
版权声明:本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。
转 https://www.cnblogs.com/snailZz/p/16198199.html
标签:异步,Task,await,执行,线程,多线程,方法 From: https://www.cnblogs.com/Leo_wl/p/16593691.html