Does the use of async/await create a new thread?

In short NO

From Asynchronous Programming with Async and Await : Threads

The async and await keywords don't cause additional threads to be created. Async methods don't require multithreading because an async method doesn't run on its own thread. The method runs on the current synchronization context and uses time on the thread only when the method is active. You can use Task.Run to move CPU-bound work to a background thread, but a background thread doesn't help with a process that's just waiting for results to become available.

According to MSDN : async keyword

An async method runs synchronously until it reaches its first await expression, at which point the method is suspended until the awaited task is complete. In the meantime, control returns to the caller of the method, as the example in the next section shows.

Here is a sample code to check it :

class Program{    static void Main(string[] args)    {        Program p = new Program();        p.Run();    }    private void Print(string txt)    {        string dateStr = DateTime.Now.ToString("HH:mm:ss.fff");        Console.WriteLine($"{dateStr} Thread #{Thread.CurrentThread.ManagedThreadId}\t{txt}");    }    private void Run()    {        Print("Program Start");        Experiment().Wait();        Print("Program End. Press any key to quit");        Console.Read();    }    private async Task Experiment()    {        Print("Experiment code is synchronous before await");        await Task.Delay(500);        Print("Experiment code is asynchronous after first await");    }}

And the result :

We see the code of Experiment() method after await executes on another Thread.

But if I replace the Task.Delay by my own code (method SomethingElse) :

   class Program{    static void Main(string[] args)    {        Program p = new Program();        p.Run();    }    private void Print(string txt)    {        string dateStr = DateTime.Now.ToString("HH:mm:ss.fff");        Console.WriteLine($"{dateStr} Thread #{Thread.CurrentThread.ManagedThreadId}\t{txt}");    }    private void Run()    {        Print("Program Start");        Experiment().Wait();        Print("Program End. Press any key to quit");        Console.Read();    }    private async Task Experiment()    {        Print("Experiment code is synchronous before await");        await SomethingElse();        Print("Experiment code is asynchronous after first await");    }    private Task SomethingElse()    {        Print("Experiment code is asynchronous after first await");        Thread.Sleep(500);        return (Task.CompletedTask);    }}

I notice the thread remains the same !

In conclusion, I'll say async/await code could use another thread, but only if the thread is created by another code, not by async/await.

In this case, I think Task.Delay created the thread, so I can conclude async/await does not create a new Thread like said by @Adriaan Stander.

Sorry for being late to the party.

I am new to TPL and I am wondering: How does the asynchronousprogramming support that is new to C# 5.0 (via the new async and awaitkeywords) relate to the creation of threads?

async/await is not introduced for thread creation, but to utilize the current thread optimally.

Your app might read files, wait for response from another server or even do a computation with high memory access (Simply any IO task). These tasks are not CPU intensive (Any task that will not use 100% of your thread).

Think about the case when you are processing 1000 non CPU intensive tasks. In this case, process of creating 1000s of OS level thread might eat up more CPU and Memory than doing actual work on a single thread (4mb per thread in Windows, 4MB * 1000 = 4GB). At the same time if you run all the tasks sequentially, you might have to wait until the IO tasks gets finished. Which end up in long time to complete the task, while keeping the CPU idle.

Since we require parallelism to complete multiple tasks quickly, at the same time all parallel tasks are not CPU hungry, but creating threads is inefficient.

The compiler will break the execution at any method call to an async method (which gets called with an await) and immediately execute the code outside of the current code branch, once an await is reached, the execution will go inside the previous async. This will be repeated again and again until all the async calls are completed and their awaiters are satisfied.

If any of the async method have heavy CPU load without a call to an async method, then yes, your system will become unresponsive and all the remaining async methods will not get called until the current task is finished.