async/await runs synchronously?

Question

Below code is from https://blog.stephencleary.com/2012/02/async-and-await.html I just added some descriptive methods

class Program
{
    async static Task Main(string[] args)
    {
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId); //thread id is 1 here
        await DoSomethingAsync();
        Console.WriteLine("do other workzzz");
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId);  //thread id is 4 here
        Console.ReadLine();
    }

    public static async Task DoSomethingAsync()
    {
        await Task.Delay(2000);    
    }
}

and the author says:

I like to think of “await” as an “asynchronous wait”. That is to say, the async method pauses until the awaitable is complete (so it waits), but the actual thread is not blocked (so it’s asynchronous).

so my questions is: why the actual thread(thread id 1 in my case) is not blocked? From my perspective, a thread is blocked because further statements will not be executed until current method has finished. We can see that Console.WriteLine("do other workzzz"); won't be executed until DoSomethingAsync() finishes, isn't it kind of blocking?

Another important thing to notice is, after DoSomethingAsync(); finishes, thread id changes from 1 to 4, there is no "actual thread" anymore. Why thread 1 disappear? shouldn't it be the thread 4 to disappear?

Answer 1

(Original question was along the lines of: "What do you call an async method when you await it rather than letting it run in parallel?")

The word I would use is "sequentially". They are running one at a time, in sequence. But that type of task (async) is still asynchronous, due to the way it is scheduled and executed. It's more than just the caller that decides whether it is asynchronous or not. (Additionally, the caller is async, and its caller will also be async, so you really can't call an asynchronous task synchronously. (If you try, using functions like Wait(), you risk deadlocks. Because under the hood, it's not the same as a synchronous function.)

Answer 2

I think the lack of variable assignments in part B is confusing you.

Part B can be rewritten as this:

var a = Task.Delay(1000);
await a;

var b = Task.Delay(1000);
await b;

var c = Task.Delay(1000);
await c;

etc...

If you invoke all the tasks at the beginning and await them all at the end (as in part A), then you can think of it as those tasks running in parallel.

await means to wait for the task (in this case, Task.Delay(1000)) to complete before moving on. Without the await, you can think of the task as being run in the background (but the main program can exit before it reaches completion)

To wait until all tasks are finished before the program exits, you can do something like this: await Task.WhenAll(taskA, taskB, …);

Answer 3

Async operations are handled differently than other methods.

Simplified explanation: your code..

async static Task Main(string[] args) 
{
    Console.WriteLine(Thread.CurrentThread.ManagedThreadId); //thread id is 1 here
    await DoSomethingAsync();
    Console.WriteLine("do other workzzz");
    Console.WriteLine(Thread.CurrentThread.ManagedThreadId);  //thread id is 4 here
    Console.ReadLine(); 
}

Gets executed as follows:

The calling thread executes..

Console.WriteLine(Thread.CurrentThread.ManagedThreadId);

The code waited upon by the await statement gets dispatched to the task scheduler, which uses a synchronization context to queue, schedule and execute it. The implementation of the synchronization context is responsible for deciding which thread this code executes in.

 await DoSomethingAsync();

The code after the await gets posted back to synchronization contex captured at the start. Again, depending on the implemenation, some other thread might execute it.

Console.WriteLine("do other workzzz");
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
Console.ReadLine(); 

Eventhough the code reads synchronously, the async/await pattern will break up the flow.

Answer 4

why the actual thread(thread id 1 in my case) is not blocked?

When await is used on an awaitable that is not complete, then that await returns from the async method. The calling thread continues executing its next piece of code.

We can see that Console.WriteLine("do other workzzz"); won't be executed until DoSomethingAsync() finishes, isn't it kind of blocking?

It doesn't block a thread. The method is "paused" at the point of the await, but there's no thread holding it in place.

For example, examine your call stack before the await and again after the await. You'll see that the call stack is not preserved, because the async method returned and the original thread continued running. After the await, that call stack is not re-entered.

Another important thing to notice is, after DoSomethingAsync(); finishes, thread id changes from 1 to 4, there is no "actual thread" anymore. Why thread 1 disappear? shouldn't it be the thread 4 to disappear?

Both threads 1 and 4 are actual threads. Thread 1 is the main thread, the one that starts the Console application. Thread 4 is a thread pool thread.

When DoSomethingAsync finishes and the await is ready to resume its async method, it has to resume it somewhere. By default an await will capture a "context"; for a console application, this is the thread pool context. So when the async method resumes, it resumes on a thread pool thread.