Why a simple await Task.Delay(1) enables parallel execution?

Question

I would like to ask simple question about code bellow:

static void Main(string[] args)
{
    MainAsync()
        //.Wait();
        .GetAwaiter().GetResult();
}

static async Task MainAsync()
{
    Console.WriteLine("Hello World!");

    Task<int> a = Calc(18000);
    Task<int> b = Calc(18000);
    Task<int> c = Calc(18000);

    await a;
    await b;
    await c;

    Console.WriteLine(a.Result);
}

static async Task<int> Calc(int a)
{
    //await Task.Delay(1);
    Console.WriteLine("Calc started");

    int result = 0;

    for (int k = 0; k < a; ++k)
    {
        for (int l = 0; l < a; ++l)
        {
            result += l;
        }
    }

    return result;
}

This example runs Calc functions in synchronous way. When the line //await Task.Delay(1); will be uncommented, the Calc functions will be executed in a parallel way.

The question is: Why, by adding simple await, the Calc function is then async? I know about async/await pair requirements. I'm asking about what it's really happening when simple await Delay is added at the beginning of a function. Whole Calc function is then recognized to be run in another thread, but why?

Edit 1:

When I added a thread checking to code:

static async Task<int> Calc(int a)
{
    await Task.Delay(1);
    Console.WriteLine(Thread.CurrentThread.ManagedThreadId);

    int result = 0;

    for (int k = 0; k < a; ++k)
    {
        for (int l = 0; l < a; ++l)
        {
            result += l;
        }
    }

    return result;
}

it is possible to see (in console) different thread id's. If await Delay line is deleted, the thread id is always the same for all runs of Calc function. In my opinion it proves that code after await is (can be) runned in different threads. And it is the reason why code is faster (in my opinion of course).

Answer 1

It's important to understand how async methods work.

First, they start running synchronously, on the same thread, just like every other method. Without that await Task.Delay(1) line, the compiler will have warned you that the method would be completely synchronous. The async keyword doesn't, by itself, make your method asynchronous. It just enables the use of await.

The magic happens at the first await that acts on an incomplete Task. At that point the method returns. It returns a Task that you can use to check when the rest of the method has completed.

So when you have await Task.Delay(1) there, the method returns at that line, allowing your MainAsync method to move to the next line and start the next call to Calc.

How the continuation of Calc runs (everything after await Task.Delay(1)) depends on if there is a "synchronization context". In ASP.NET (not Core) or a UI application, for example, the synchronization context controls how the continuations run and they would run one after the other. In a UI app, it would be on the same thread it started from. In ASP.NET, it may be a different thread, but still one after the other. So in either case, you would not see any parallelism.

However, because this is a console app, which does not have a synchronization context, the continuations happen on any ThreadPool thread as soon as the Task from Task.Delay(1) completes. That means each continuation can happen in parallel.

Also worth noting: starting with C# 7.1 you can make your Main method async, eliminating the need for your MainAsync method:

static async Task Main(string[] args)

Answer 2

layman's version....

nothing in the process is yielding CPU time back without 'delay' and so it doesn't give anything else CPU time, you are confusing this with multiple threaded code. "async and await" is not about multiple threaded but about using the CPU (thread/threads) when its doing non CPU work" aka writing to disk. Writing to disk does not need the thread (CPU). So when something is async, it can free the thread and be used for something else instead of waiting for non CPU (oi task) to complete.

@sunside is saying the same thing just more technically.

static async Task<int> Calc(int a)
{
    //faking a asynchronous .... this will give this thread to something else 
    // until done then return here...
    // does not make sense... as your making this take longer for no gain.
    await Task.Delay(1);


    Console.WriteLine("Calc started");

    int result = 0;
   
    for (int k = 0; k < a; ++k)
    {
        for (int l = 0; l < a; ++l)
        {
            result += l;
        }
    }

    return result;
}

vs

static async Task<int> Calc(int a)
{
    
    using (var reader = File.OpenText("Words.txt"))
    {
        //real asynchronous .... this will give this thread to something else 
        var fileText = await reader.ReadToEndAsync();
        // Do something with fileText...
    }
        
    Console.WriteLine("Calc started");

    int result = 0;
   
    for (int k = 0; k < a; ++k)
    {
        for (int l = 0; l < a; ++l)
        {
            result += l;
        }
    }

    return result;
}

the reason it looks like its in "parallel way" is that its just give the others tasks CPU time.

example; aka without delay

• await a; do this (no actual aysnc work)
• await b; do this (no actual aysnc work)
• await c; do this (no actual aysnc work)

example 2;aka with delay

• await a; start this then pause this (fake async), start b but come back and finish a
• await b; start this then pause this (fake async), start c but come back and finish b
• await c; start this then pause this (fake async), come back and finish c

what you should find is although more is started sooner, the overall time will be longer as it as to jump between tasks for no benefit with a faked asynchronous task. where as, if the await Task.Delay(1) was a real async function aka asynchronous in nature then the benefit would be it can start the other work using the thread which would of been blocked... while it waits for something which does not require the thread.

update silly code to show its slower... Make sure you are in "Release" mode you should always ignore the first run... these test are silly and you would need to use https://github.com/dotnet/BenchmarkDotNet to really see the diff

static void Main(string[] args)
{
    Console.WriteLine("Exmaple1 - no Delay, expecting it to be faster, shorter times on average");
    for (int i = 0; i < 10; i++)
    {
        Exmaple1().GetAwaiter().GetResult();
    }

    Console.WriteLine("Exmaple2- with Delay, expecting it to be slower,longer times on average");
    for (int i = 0; i < 10; i++)
    {
        Exmaple2().GetAwaiter().GetResult();
    }
}


static async Task Exmaple1()
{
    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();
    Task<int> a = Calc1(18000); await a;
    Task<int> b = Calc1(18000); await b;
    Task<int> c = Calc1(18000); await c;
    stopwatch.Stop();
    Console.WriteLine("Time elapsed: {0}", stopwatch.Elapsed);
}

static async Task<int> Calc1(int a)
{
    int result = 0;
    for (int k = 0; k < a; ++k) { for (int l = 0; l < a; ++l) { result += l; } }
    return result;
}

static async Task Exmaple2()
{
    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();
    Task<int> a = Calc2(18000); await a;
    Task<int> b = Calc2(18000); await b;
    Task<int> c = Calc2(18000); await c;
    stopwatch.Stop();
    Console.WriteLine("Time elapsed: {0}", stopwatch.Elapsed);
}

static async Task<int> Calc2(int a)
{
    await Task.Delay(1);
    int result = 0;
    for (int k = 0; k < a; ++k){for (int l = 0; l < a; ++l) { result += l; } }
    return result;
}