Async/Await with threads (C# 7.2)

Question

I have this code and as you can see I created two examples, Parallel and Notparallel.

I expected both to return me 3000ms, because both should run async (2000 and 3000) and the total time would be 3000, but Nonparallel, is taking 5000ms, where it is the sum of the two, it seems that one waits for the other to finish.. even though you’re async.

static class Program
{
    static async Task<string> GetTaskAsync(int timeout)
    {
        Console.WriteLine("Task Thread: " + Thread.CurrentThread.ManagedThreadId);
        await Task.Delay(timeout);
        return timeout.ToString();
    }

    static async Task Main()
    {
        Console.WriteLine("Main Thread: " + Thread.CurrentThread.ManagedThreadId);

        Console.WriteLine("Should be greater than 5000");
        await Watch(NotParallel);
        Console.WriteLine("Should be less than 5000");
        await Watch(Parallel);
    }

    public static async Task Parallel()
    {
        var res1 = GetTaskAsync(2000);
        var res2 = GetTaskAsync(3000);

        Console.WriteLine("result: " + await res1 + await res2);
    }

    public static async Task NotParallel()
    {
        var res1 = await GetTaskAsync(2000);
        var res2 = await GetTaskAsync(3000);

        Console.WriteLine("result: " + res1 + res2);
    }

    private static async Task Watch(Func<Task> func) {
        var sw = new Stopwatch();
        sw.Start();

        await func?.Invoke();

        sw.Stop();
        Console.WriteLine("Elapsed: " + sw.ElapsedMilliseconds);
        Console.WriteLine("---------------");
    }
}

Example of the Result:

Answer 1

A common mistake is to think that asymchronism is synonymous with parallelism. The use of async is also not always well understood.

Use async, alone, it does not render the method (the code it executes) asynchronous. async only allows the word to be used await.
What allows certain code to be executed asynchronously is the Task.

The joint use of async/await allows write/mix sequentially synchronous and asynchronous code.
Each line of code is executed sequentially, when a line with await the execution of the method is suspended and the execution is returned to the calling code. When the asynchronous operation ends, the execution is resumed in the next line and proceeds sequentially.

This misunderstanding makes it used async in methods where it is not necessary:

private async Task<Resultado> MetodoAsync()
{
    ....
    ....
    return await opAsync();
}

There’s only need to use await if, in that method, you need to do something with the result and/or after the asynchronous operation has ended.
If not, do not use async, just return to Task.

private Task<Resultado> Metodo()
{
    ....
    ....
    return OpAsync();
}

When you’re ready to deal with the outcome, then yes, use async/await

That said, let’s look at each of the methods:

• Notparallel()

  Each of the calls to GetTaskAsync() is made with await. When executing the first call(GetTaskAsync(2000)) the execution is released (the method returns immediately), waiting for it to end and then proceeding with the second call(GetTaskAsync(3000)). That is to say, GetTaskAsync(3000) is called only after GetTaskAsync(2000) have finished.

• Parallel()

  How is it not used wait in the call to GetTaskAsync() the calls are executed immediately one after the other and the tasks are executed in "parallel" (simultaneous law-a).

I simplified the code to try to show that "parallelism" has, in this case, only to do with the moments (instants) in which each call to GetTaskAsync() is made.
In this situation(console application) only the method GetTaskAsync() needs to be declared async.
He is the one who needs to release the execution to allow it to be called again, in the method Parallel(), before ending the previous call.

static class Program
{
    static async Task<string> GetTaskAsync(int timeout)
    {
        Console.WriteLine("Task Thread: " + Thread.CurrentThread.ManagedThreadId);
        await Task.Delay(timeout);
        return timeout.ToString();
    }

    private static void Main()
    {
        Console.WriteLine("Main Thread: " + Thread.CurrentThread.ManagedThreadId);

        Console.WriteLine("Should be greater than 5000");
        Watch(NotParallel);
        Console.WriteLine("Should be less than 5000");
        Watch(Parallel);
        Console.ReadKey();
    }

    public static void Parallel()
    {
        var res1 = GetTaskAsync(2000);
        var res2 = GetTaskAsync(3000);

        Console.WriteLine("result: " + res1.Result + " " + res2.Result);
    }

    public static void NotParallel()
    {
        var res1 = GetTaskAsync(2000).Result;
        var res2 = GetTaskAsync(3000).Result;

        Console.WriteLine("result: " + res1 + " " + res2);
    }

    private static void Watch(Action func)
    {
        var sw = new Stopwatch();
        sw.Start();

        func();

        sw.Stop();
        Console.WriteLine("Elapsed: " + sw.ElapsedMilliseconds);
        Console.WriteLine("---------------");
    }
}

Answer 2

The sum in the NotParalel() is precisely why you are waiting for an execution to finish and then run the next one and finally return, on account of the await.

public static async Task NotParallel()
{
    //A atribuição de res1 deve esperar o resultado de GetTaskAsync()
    var res1 = await GetTaskAsync(2000);

    //Somente depois de res1 receber sua atribuição a de res2 deve esperar
    // o novo GetTaskAsync(3000)
    var res2 = await GetTaskAsync(3000);

    //Logo o resultado será no mínimo 5000ms porque ele parou as duas vezes
    Console.WriteLine("result: " + res1 + res2);
}

Now in parallel, see the difference:

public static async Task Parallel()
{
    //Dispara a atribuição de assíncrona de res1 e segue a execução
    var res1 = GetTaskAsync(2000);

    //Dispara a atribuição assíncrona de res2 e segue a execução
    var res2 = GetTaskAsync(3000);

    //Agora essa linha espera até que res1 e res2 tenham recebido
    //suas atribuições e como a maior espera é de res2, res1 já terá
    //recebido a sua antes e o tempo total de espera é de apenas 3000ms 
    Console.WriteLine("result: " + await res1 + await res2);
}

This is precisely why one method is called parallel and the other is not. This is the difference in running time between the two and where you will begin to give due importance to parallelism and asynchronous programming to get the best performance in time in your applications.

To further deepen the subject you can consult Microsoft’s own recommendations for this type and implementation in C#.

Asynchronous programming with Async and Await (C# and Visual Basic)

Asynchronous programming based on tasks