ConfigureAwait pushes the continuation to a pool thread

by

Why ConfigureAwait pro-actively pushes the await continuation to a pool thread here?

It doesn’t “push it to a thread pool thread” as much as say “don’t force myself to come back to the previous SynchronizationContext“.

If you don’t capture the existing context, then the continuation which handles the code after that await will just run on a thread pool thread instead, since there is no context to marshal back into.

Now, this is subtly different than “push to a thread pool”, since there isn’t a guarantee that it will run on a thread pool when you do ConfigureAwait(false). If you call:

await FooAsync().ConfigureAwait(false);

It is possible that FooAsync() will execute synchronously, in which case, you will never leave the current context. In that case, ConfigureAwait(false) has no real effect, since the state machine created by the await feature will short circuit and just run directly.

If you want to see this in action, make an async method like so:

static Task FooAsync(bool runSync)
{
   if (!runSync)
       await Task.Delay(100);
}

If you call this like:

await FooAsync(true).ConfigureAwait(false);

You’ll see that you stay on the main thread (provided that was the current context prior to the await), since there is no actual async code executing in the code path. The same call with FooAsync(false).ConfigureAwait(false); will cause it to jump to thread pool thread after execution, however.

More Related Contents:

  1. Cancelling a pending task synchronously on the UI thread
  2. The lack of non-capturing Task.Yield forces me to use Task.Run, why follow that?
  3. Wrapping ManualResetEvent as awaitable task
  4. Running multiple async tasks and waiting for them all to complete
  5. StaTaskScheduler and STA thread message pumping
  6. Run async method regularly with specified interval
  7. Does the use of async/await create a new thread?
  8. Why should I prefer single ‘await Task.WhenAll’ over multiple awaits?
  9. Regarding usage of Task.Start() , Task.Run() and Task.Factory.StartNew()
  10. Task sequencing and re-entracy
  11. How to use non-thread-safe async/await APIs and patterns with ASP.NET Web API?
  12. Multiple Parallel.ForEach loops in .Net
  13. How to put a task to sleep (or delay) in C# 4.0?
  14. Waiting for async/await inside a task
  15. Async/Await vs Threads
  16. Revisiting Task.ConfigureAwait(continueOnCapturedContext: false)
  17. If my interface must return Task what is the best way to have a no-operation implementation?
  18. EF Data Context – Async/Await & Multithreading
  19. multiple awaits vs Task.WaitAll – equivalent?
  20. Executing tasks in parallel
  21. Difference between returning and awaiting a Task in an async method [duplicate]
  22. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  23. A pattern for self-cancelling and restarting task
  24. How to correctly write Parallel.For with async methods
  25. How to get awaitable Thread.Sleep?
  26. SynchronizationLockException on Monitor.Exit when using await
  27. Queue of async tasks with throttling which supports muti-threading
  28. Converting async/await to Task.ContinueWith
  29. Faulted vs Canceled task status after CancellationToken.ThrowIfCancellationRequested
  30. Create a completed Task

Leave a Comment