Async method not working parallel? Simple Iteration inside both Async method, Please suggest How to make it run parallel?

Question

I am trying to figure it out that why these two Async method not working parallel. Note that each method returns some html, and for this Iteration inside it (its demo code) (original code is in my .Net project).

Each method individually takes 9 seconds to complete.

Both method are Async even it takes 18 seconds to complete if its invoke and run in single method. It means it not runs parallel.

Overall what i want is, It should take 9 second to complete both the method. How it is possible? Please suggest to run both method parallel. (I want this because in my project there are many method inside one method, i want all runs parallel)

Thanks in advance.

Please review below code:

namespace LearnAynchStackOverflow
{
class Program
{
    static async Task Main(string[] args)
    {
        var startTime = DateTime.Now;
        Console.WriteLine($"Start time: {startTime}");

        var emailHtml = EmailTemplate.EmailHtml();
        var smsHtml = SmsTemplate.SmsHtml();

        var f = await Task.WhenAll(emailHtml, smsHtml);

        var endTime = DateTime.Now;
        Console.WriteLine($"End time: {endTime}");

        Console.ReadLine();
    }
}

public class EmailTemplate
{
    //This method takes 9 seconds to complete
    public static async Task<string> EmailHtml()
    {
        string str = string.Empty;
        for (int i = 0; i < 25000; i++)
        {
            str += "html1" + i + " ";
            str += "html1" + i + " ";
        }
        var a = await Task.FromResult(str);
        return a;
    }
}

public class SmsTemplate
{
    //This method takes 9 seconds to complete
    public static async Task<string> SmsHtml()
    {
        string str = string.Empty;
        for (int i = 0; i < 25000; i++)
        {
            str += "html2" + i + " ";
            str += "html2" + i + " ";
        }
        var z = await Task.FromResult(str);
        return z;
    }
}
}

And Below is my console result which takes 18 seconds:

Answer 1

Your methods are asynchronous only on paper. They both always complete synchronously, because await Task.FromResult(str) completes immediately without any asynchronous operations. Both calls:

var emailHtml = EmailTemplate.EmailHtml();
var smsHtml = SmsTemplate.SmsHtml();

run the loop synchronously and return a completed task. Then the Task.WhenAll also returns a completed task. There is never any asynchrony, no continuations, only plain old sequential execution.

Making your method async doesn't magically cause it to be ran on a separate thread, actually, There Is No Thread. Your task has nothing to do with asynchronous operations. If you want to run CPU-bound tasks on the thread pool, use Task.Run

public class EmailTemplate
{
    public static string EmailHtml()
    {
        string str = string.Empty;
        for (int i = 0; i < 25000; i++)
        {
            str += "html1" + i + " ";
            str += "html1" + i + " ";
        }
        return str;
    }
}

public class SmsTemplate
{
    public static string SmsHtml()
    {
        string str = string.Empty;
        for (int i = 0; i < 25000; i++)
        {
            str += "html2" + i + " ";
            str += "html2" + i + " ";
        }
        return str;
    }
}

class Program
{
    static async Task Main(string[] args)
    {
        var startTime = DateTime.Now;
        Console.WriteLine($"Start time: {startTime}");

        var emailHtml = Task.Run(() => EmailTemplate.EmailHtml());
        var smsHtml = Task.Run(() => SmsTemplate.SmsHtml());

        var f = await Task.WhenAll(emailHtml, smsHtml);

        var endTime = DateTime.Now;
        Console.WriteLine($"End time: {endTime}");

        Console.ReadLine();
    }
}

As an aside, don't you think that concatenating a string 25000 times taking 9 seconds is a bit pathological? I do, that's why I'd use a StringBuilder.

public static string EmailHtml()
{
    var stringBuilder = new StringBuilder();
    for (int i = 0; i < 25000; i++)
    {
        stringBuilder.Append("html1").Append(i).Append(" ");
        // I don't know if this duplication is intentional, but I left it in case it was.
        stringBuilder.Append("html1").Append(i).Append(" ");
    }
    return stringBuilder.ToString();
}

Answer 2

Your sample code runs synchronously. To understand why, you need to understand how asynchronous methods work.

All asynchronous methods start running synchronously - just like any other method. The magic happens at the first await that acts on an incomplete Task. At that point, the method returns its own incomplete Task that the calling method can use to know when the task has actually finished.

Your sample code never returns an incomplete Task. Task.FromResult returns a completed Task. When await sees a completed Task, your method continues running synchronously, just like any other method.

So when you do this:

var emailHtml = EmailTemplate.EmailHtml();
var smsHtml = SmsTemplate.SmsHtml();

Your call to SmsHtml() doesn't even start until EmailHtml() has fully completed.

If you are using await Task.FromResult to try to simulate some asynchronous work (like actually sending an SMS or email), then that won't work. You can use Task.Delay() instead. That will return an incomplete Task that will resolve when the timer runs out.

See if you get different results using this code:

public class EmailTemplate
{
    //This method takes 9 seconds to complete
    public static async Task<string> EmailHtml()
    {
        string str = string.Empty;
        for (int i = 0; i < 25000; i++)
        {
            str += "html1" + i + " ";
            str += "html1" + i + " ";
        }
        await Task.Delay(9000); //wait 9 seconds asynchronously
        return str;
    }
}

public class SmsTemplate
{
    //This method takes 9 seconds to complete
    public static async Task<string> SmsHtml()
    {
        string str = string.Empty;
        for (int i = 0; i < 25000; i++)
        {
            str += "html2" + i + " ";
            str += "html2" + i + " ";
        }
        await Task.Delay(9000); //wait 9 seconds asynchronously
        return str;
    }
}

Your code in Main is correct for what you're trying to do. But just note that asynchronous does not mean parallel:

• Parallel means two lines of code are being evaluated simultaneously (on different threads)
• Asynchronous means releasing the current thread while you wait for some external thing to happen. This allows you to start some other operation while you wait.

Parallel is about how your code runs. Asynchronous is about how your code waits.

In the changed code I gave, the initial parts of each method will never run in parallel. EmailHtml() will run up until the await, when it returns a Task. Then SmsHtml() will start running, up until the await. That will happen one after the other.

The continuations of those methods (everything after await) might run in parallel (on different threads) depending on the type of application.

Microsoft has a series of well-written articles about Asynchronous programming with async and await that are worth reading. It should help you understand better how all this works.

Answer 3

I have just copied and run your code and it completes in 7 seconds. It seems to be correct. Your results may differ according to many reasons. What kind of app are you running (ASP.NET, Console)? What your PC configuration is? What version of .NET are you using?

Answer 4

Async keyword makes the Task inside the block run in parallel and all other sync blocks run sequentially. Making the method async will never make the code async.

What does async keyword do?

public static async Task<string> EmailHtml()
    {
        stmt1;
        (task)stmt2;
        stmt3;
        (task)stmt4;
    }

Here, EmailHtml() starts running sequentially, when it encounters a task (stmt2, stmt4) a new thread is taken from thread pool and will run in background (will never be merged to the main thread until it is awaited) and other stmts (1 & 3) will be sequential.

How to make the code run in parallel?
Place the code inside SmsHtml and EmailHtml inside Task.Run or Task.Factory.StartNew (will explicitly ask to run the block inside a new thread) according to your use case. Now, these two methods run in a different thread and the rest of your code will make it run in 9 seconds.

public static async Task<string> EmailHtml()
{
    return Task.Run(() => {return str;});
}

Note: All the tasks mentioned here are assumed to be running aync