异步方法在同一线程上运行，没有时间延迟

Question

This is what AsyncMethods class looks like:

public class AsyncMethods
{
    public static async Task<double> GetdoubleAsync()
    {
        Console.WriteLine("Thread.CurrentThread.ManagedThreadId: " + Thread.CurrentThread.ManagedThreadId);
        await Task.Delay(1000);
        return 80d;
    }
    public static async Task<string> GetStringAsync()
    {
        Console.WriteLine("Thread.CurrentThread.ManagedThreadId: " + Thread.CurrentThread.ManagedThreadId);
        await Task.Delay(1000);
        return "async";
    }
    public static async Task<DateTime> GetDateTimeAsync()
    {
        Console.WriteLine("Thread.CurrentThread.ManagedThreadId: " + Thread.CurrentThread.ManagedThreadId);
        await Task.Delay(1000);
        return DateTime.Now;
    }
}

This what my main method looks like:

static void Main(string[] args)
{
    while (Console.ReadLine() != "exit")
    {
        Console.WriteLine("Thread.CurrentThread.ManagedThreadId: " + Thread.CurrentThread.ManagedThreadId);
        DateTime dt = DateTime.Now;
        var res = GetStuffAsync().Result;
        var ts = DateTime.Now - dt;
        Console.WriteLine(res);
        Console.WriteLine("Seconds taken: " + ts.Seconds + " milliseconds taken: " + ts.Milliseconds);
    }
    Console.ReadLine();
    return;
}
static async Task<object> GetStuffAsync()
{
    var doubleTask = AsyncMethods.GetdoubleAsync();
    var StringTask = AsyncMethods.GetStringAsync();
    var DateTimeTask = AsyncMethods.GetDateTimeAsync();

    return new
    {
        _double = await doubleTask,
        _String = await StringTask,
        _DateTime = await DateTimeTask,
    };
}

As it can be seen in each method i added a delay of 1 second. Here is the output:

Thread.CurrentThread.ManagedThreadId: 10
Thread.CurrentThread.ManagedThreadId: 10
Thread.CurrentThread.ManagedThreadId: 10
Thread.CurrentThread.ManagedThreadId: 10
{ _double = 80, _String = async, _DateTime = 2/15/2017 4:32:00 AM }
Seconds taken: 1 milliseconds taken: 40

Thread.CurrentThread.ManagedThreadId: 10
Thread.CurrentThread.ManagedThreadId: 10
Thread.CurrentThread.ManagedThreadId: 10
Thread.CurrentThread.ManagedThreadId: 10
{ _double = 80, _String = async, _DateTime = 2/15/2017 4:32:03 AM }
Seconds taken: 1 milliseconds taken: 16

Now i have 2 questions:

1. How come everything happened on a single thread?
2. Why was the Delay only 1 second when i waited 3 seconds?

Answer 1

First off: if you have two questions please ask two questions . Don't put two questions in one question.

How come everything happened on a single thread?

That's the wrong question to ask. The correct question is: why do you think anything should happen on a second thread?

Here, I'll give you a task: wait five minutes, and then check your email. While you're waiting, make a sandwich. Did you have to hire someone to either do the waiting or make the sandwich ? Obviously not. Threads are workers. There's no need to hire a worker if the job can be done by one worker.

The whole point of await is to avoid going to extra threads if you don't need to. In this case you don't need to.

Why was the Delay only 1 second when i waited 3 seconds?

Compare these two workflows.

• Wait five minutes; while you're waiting, make a sandwich
• then check your email
• then wait five minutes; while you're waiting, make a sandwich
• then check your email
• then wait five minutes; while you're waiting, make a sandwich
• then check your email

If you execute that workflow, you'll wait a total of fifteen minutes.

The workflow you wrote was:

• Wait five minutes
• simultaneously, wait five minutes
• simultaneously, wait five minutes
• while you're waiting, make a sandwich
• then check your email

You only wait five minutes with that workflow; all the delays happen at the same time.

Do you see how you wrote your program incorrectly now?

The key insight to understand here is that an await is a point in a program where the continuation of the await is delayed until after the awaited task completes .

If you don't put in an await, the program continues by itself without waiting. That's the meaning of await .

Answer 2

They all start on the same thread. When you call your three Async methods in sequence, they all execute synchronously up until the first await call. (After the await , they become state machines that pick up where they left off whenever they get scheduled. If you checked the thread ID after the await Task.Delay call, you would probably find that the continuations ran on different threads -- at least here in a console app.)

As for why it's only delaying 1 second... that's what you're telling it to do. You've got three async tasks, all running simultaneously, each delaying for one second. You're not saying "[a]wait until the first task is done before starting the second" -- in fact you're carefully doing the opposite, starting all three and then awaiting all three -- so they run in parallel.

Answer 3

Your Console.WriteLine() calls in GetdoubleAsync(), GetStringAsync(), and GetDateTimeAsync() happened in the calling thread because they happened before the first continuation.

Your await Task.Delay() calls yielded the thread back to the calling code.

When the task returned by Task.Delay() completed, the continuation on those Tasks returned their values and set their tasks as completed.

This allowed your 3 awaits (in sequential, synchronous order) in GetStuffAsync() to return. Each one had to wait 1 second before marked as completed, but they were yielding and happening at the same time.

I think you are looking for System.Threading.Tasks.Parallel to do things at the same time. Async...await is useful for yielding threads.

Answer 4

You're starting all your tasks at the same time so they're all going to run in parallel, not in sequence. That's why everything completes after 1000 milliseconds.

Additionally, async doesn't create new threads, it uses the current thread asynchronously. You can see this kind of behaviour in async javascript (which is a single threaded environment) or coroutines in Unity3D. They both allow async behaviour without threads.

So each of your tasks is being run on the same thread and completes in 1 second.