But, since await is generally a No.Op(No Operation), does it make the
underlying thread not being reusable until execution of awaited task
completes?
I'm not sure where you got this information from, but await
is certainly not a No-Op. Calling await
on a Task
, for example, will invoke a logical call to Task.GetAwaiter
, where the TaskAwaiter
has to implement INotifyCompletion
or ICriticalNotifyCompletion
interface, which tells the compiler how to invoke the continuation (everything after the first await
).
The complete structure of async-await
transforms your call to a state-machine such that when the state-machine hits the first await
, it will first check to see if the called method completed, and if not will register the continuation and return from that method call. Later, once that method completes, it will re-enter the state-machine in order to complete the method. And that is logically how you see the line after await
being hit.
But, since we are awaiting, does it block the underlying thread
resulting thread not being used to execute any tasks?
No, creating an entire mechanism only to block the calling thread would be useless. async-await
allow you to actually yield the calling thread back to the caller which allows him to continue execution on that same thread, while the runtime takes care of queuing and invoking the completion.
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…