Difference between the TPL & async/await (Thread handling)

by

I believe the TPL (TaskFactory.Startnew) works similar to ThreadPool.QueueUserWorkItem in that it queues up work on a thread in the thread pool.

Pretty much.

From what i’ve been reading it seems like async/await only “sometimes” creates a new thread.

Actually, it never does. If you want multithreading, you have to implement it yourself. There’s a new Task.Run method that is just shorthand for Task.Factory.StartNew, and it’s probably the most common way of starting a task on the thread pool.

If you were dealing with IO completion ports i can see it not having to create a new thread but otherwise i would think it would have to.

Bingo. So methods like Stream.ReadAsync will actually create a Task wrapper around an IOCP (if the Stream has an IOCP).

You can also create some non-I/O, non-CPU “tasks”. A simple example is Task.Delay, which returns a task that completes after some time period.

The cool thing about async/await is that you can queue some work to the thread pool (e.g., Task.Run), do some I/O-bound operation (e.g., Stream.ReadAsync), and do some other operation (e.g., Task.Delay)… and they’re all tasks! They can be awaited or used in combinations like Task.WhenAll.

Any method that returns Task can be awaited – it doesn’t have to be an async method. So Task.Delay and I/O-bound operations just use TaskCompletionSource to create and complete a task – the only thing being done on the thread pool is the actual task completion when the event occurs (timeout, I/O completion, etc).

I guess my understanding of FromCurrentSynchronizationContext always was a bit fuzzy also. I always throught it was, in essence, the UI thread.

I wrote an article on SynchronizationContext. Most of the time, SynchronizationContext.Current:

  • is a UI context if the current thread is a UI thread.
  • is an ASP.NET request context if the current thread is servicing an ASP.NET request.
  • is a thread pool context otherwise.

Any thread can set its own SynchronizationContext, so there are exceptions to the rules above.

Note that the default Task awaiter will schedule the remainder of the async method on the current SynchronizationContext if it is not null; otherwise it goes on the current TaskScheduler. This isn’t so important today, but in the near future it will be an important distinction.

I wrote my own async/await intro on my blog, and Stephen Toub recently posted an excellent async/await FAQ.

Regarding “concurrency” vs “multithreading”, see this related SO question. I would say async enables concurrency, which may or may not be multithreaded. It’s easy to use await Task.WhenAll or await Task.WhenAny to do concurrent processing, and unless you explicitly use the thread pool (e.g., Task.Run or ConfigureAwait(false)), then you can have multiple concurrent operations in progress at the same time (e.g., multiple I/O or other types like Delay) – and there is no thread needed for them. I use the term “single-threaded concurrency” for this kind of scenario, though in an ASP.NET host, you can actually end up with “zero-threaded concurrency”. Which is pretty sweet.

More Related Contents:

  1. Does the use of async/await create a new thread?
  2. An async/await example that causes a deadlock
  3. Using async/await for multiple tasks
  4. I want await to throw AggregateException, not just the first Exception
  5. Cancelling a pending task synchronously on the UI thread
  6. ConfigureAwait pushes the continuation to a pool thread
  7. Task.Yield – real usages?
  8. Using async without await?
  9. SynchronizationLockException on Monitor.Exit when using await
  10. Faulted vs Canceled task status after CancellationToken.ThrowIfCancellationRequested
  11. Synchronous implementation of interface that returns Task
  12. The lack of non-capturing Task.Yield forces me to use Task.Run, why follow that?
  13. Wrapping ManualResetEvent as awaitable task
  14. Calling TaskCompletionSource.SetResult in a non blocking manner
  15. Best practice to call ConfigureAwait for all server-side code
  16. Difference between -pthread and -lpthread while compiling
  17. Running multiple async tasks and waiting for them all to complete
  18. Regarding usage of Task.Start() , Task.Run() and Task.Factory.StartNew()
  19. Task sequencing and re-entracy
  20. How, if at all, do Erlang Processes map to Kernel Threads?
  21. How to detect and debug multi-threading problems?
  22. multiple awaits vs Task.WaitAll – equivalent?
  23. Thread references require static lifetime?
  24. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  25. A pattern for self-cancelling and restarting task
  26. Queue of async tasks with throttling which supports muti-threading
  27. How do I create a custom SynchronizationContext so that all continuations can be processed by my own single-threaded event loop?
  28. Can’t await async extension method
  29. How do I get a return value from Task.WaitAll() in a console app?
  30. call async method without await #2

Leave a Comment