MVC4 async and Parallel execution

Question

So I'm trying to get my head around this new 'async' stuff in .net 4.5. I previously played a bit with async controllers and the Task Parallel Library and wound up with this piece of code:

Take this model:

public class TestOutput
{
    public string One { get; set; }
    public string Two { get; set; }
    public string Three { get; set; }

    public static string DoWork(string input)
    {
        Thread.Sleep(2000);
        return input;
    }
}

Which is used in a controller like this:

public void IndexAsync()
{
    AsyncManager.OutstandingOperations.Increment(3);

    Task.Factory.StartNew(() => 
        { 
            return TestOutput.DoWork("1"); 
        })
        .ContinueWith(t => 
        { 
            AsyncManager.OutstandingOperations.Decrement(); 
            AsyncManager.Parameters["one"] = t.Result; 
        });
    Task.Factory.StartNew(() =>
        {
            return TestOutput.DoWork("2");
        })
        .ContinueWith(t =>
        {
            AsyncManager.OutstandingOperations.Decrement();
            AsyncManager.Parameters["two"] = t.Result;
        });
    Task.Factory.StartNew(() =>
        {
            return TestOutput.DoWork("3");
        })
        .ContinueWith(t =>
        {
            AsyncManager.OutstandingOperations.Decrement();
            AsyncManager.Parameters["three"] = t.Result;
        });
}

public ActionResult IndexCompleted(string one, string two, string three)
{
    return View(new TestOutput { One = one, Two = two, Three = three });
}

This controller renders the view in 2 seconds, thanks to the magic of the TPL.

Now I expected (rather naively) that the code above would translate into the following, using the new 'async' and 'await' features of C# 5:

public async Task<ActionResult> Index()
{
    return View(new TestOutput
    {
        One = await Task.Run(() =>TestOutput.DoWork("one")),
        Two = await Task.Run(() =>TestOutput.DoWork("two")),
        Three = await Task.Run(() =>TestOutput.DoWork("three"))
    });
}

This controller renders the view in 6 seconds. Somewhere in the translation the code became no longer parallel. I know async and parallel are two different concepts, but somehow I thought the code would work the same. Could someone point out what is happening here and how it can be fixed?

So basically I mixed up asynchonisity and parallelism. I (mistakenly) thought that the actual waiting would happen when the result of a task is eventually used (not unlike a linq query is only executed when it is enumerated). — Lodewijk
– Lodewijk, Commented Jan 31, 2012 at 12:08

Stephen Cleary · Accepted Answer · 2012-01-31 03:10:36Z

20

Somewhere in the translation the code became no longer parallel.

Precisely. await will (asynchronously) wait for a single operation to complete.

Parallel asynchronous operations can be done by starting the actual Tasks but not awaiting them until later:

public async Task<ActionResult> Index() 
{
  // Start all three operations.
  var tasks = new[]
  {
    Task.Run(() =>TestOutput.DoWork("one")), 
    Task.Run(() =>TestOutput.DoWork("two")), 
    Task.Run(() =>TestOutput.DoWork("three"))
  };

  // Asynchronously wait for them all to complete.
  var results = await Task.WhenAll(tasks);

  // Retrieve the results.
  return View(new TestOutput
  {
    One = results[0],
    Two = results[1],
    Three = results[2]
  }); 
}

P.S. There's also a Task.WhenAny.

answered Jan 31, 2012 at 3:10

Stephen Cleary

460k78 gold badges720 silver badges858 bronze badges

Sign up to request clarification or add additional context in comments.

7 Comments

Lodewijk Over a year ago

Okay, I understand the difference between async an parallel (I kind of guesses it myself while asking the question), but is it nececary to 'await' the results of Task.WhenAll? If the action in the controller is already 'async', will awaiting inside the async method not create an extra burden on the system?

Stephen Cleary Over a year ago

Yes, it's necessary, because you need the tasks to complete before constructing the view. Using asynchronous awaits is less burden than synchronously blocking - it's roughly the same as the old AsyncManager approach.

Stephen Cleary Over a year ago

One important point: the async keyword does nothing except to allow the await keyword in that method. It's the await keyword - not the async keyword - that makes things asynchronous. So you really should have an await somewhere in every async method (the compiler will warn you if you don't).

Lodewijk Over a year ago

Okay, I think I get async/await now. Thanks for you help. Anser accepted :)

Stephen Cleary Over a year ago

@Steve: The assignment to results will not happen until all the tasks have completed. No threads are blocked in this code sample.

|

Justin Pihony · Accepted Answer · 2012-01-31 01:23:06Z

No, you stated the reason that this is different already. Parallel and Async are two different things.

The Task version works in 2 seconds because it runs the three operations at the same time (as long as you have 3+ processors).

The await is actually what it sounds like, the code will await the execution of the Task.Run before continuing to the next line of code.

So, the big difference between the TPL version and the async version are that the TPL version runs in any order because all of the tasks are independent of each other. Whereas, the async version runs in the order that the code is written. So, if you want parallel, use the TPL, and if you want async, use async.

The point of async is the ability to write synchronous looking code that will not lock up a UI while a long running action is happening. However, this is typically an action that all the processor is doing is waiting for a response. The async/await makes it so that the code that called the async method will not wait for the async method to return, that is all. So, if you really wanted to emulate your first model using async/await (which I would NOT suggest), you could do something like this:

MainMethod()
{
    RunTask1();
    RunTask2();
    RunTask3();
}

async RunTask1()
{
    var one = await Task.Factory.StartNew(()=>TestOutput.DoWork("one"));
    //do stuff with one
}

async RunTask2()
{
    var two= await Task.Factory.StartNew(()=>TestOutput.DoWork("two"));
    //do stuff with two
}

async RunTask3()
{
    var three= await Task.Factory.StartNew(()=>TestOutput.DoWork("three"));
    //do stuff with three
}

The code path will go something like this (if the tasks are long running)

main call to RunTask1
RunTask1 awaits and returns
main call to RunTask2
RunTask2 awaits and returns
main call to RunTask3
RunTask3 awaits and returns
main is now done
RunTask1/2/3 returns and continues doing something with one/two/three
Same as 7, except less the one that already completed
Same as 7, except less the two that already completed

****A big disclaimer about this, though. Await will run synchronously if the task is already completed by the time that the await is hit. This saves the runtime from having to perform its vudu :) since it is not needed. This will make the code flow above incorrect as the flow is now synchronous****

Eric Lippert's blog post on this explains things much better than I am doing :) http://blogs.msdn.com/b/ericlippert/archive/2010/10/29/asynchronous-programming-in-c-5-0-part-two-whence-await.aspx

Hopefully, that helps dispel some of your questions about async versus TPL? The biggest thing to take away is that async is NOT parallel.

I liked your answer, but I accepted the other one because it contained a workable version of my sample.

Collectives™ on Stack Overflow

MVC4 async and Parallel execution

2 Answers 2

7 Comments

1 Comment

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

7 Comments

1 Comment

Related