Calling TaskCompletionSource.SetResult in a non blocking manner

by

I’ve discovered that TaskCompletionSource.SetResult(); invokes the code awaiting the task before returning. In my case that result in a deadlock.

Yes, I have a blog post documenting this (AFAIK it’s not documented on MSDN). The deadlock happens because of two things:

  1. There’s a mixture of async and blocking code (i.e., an async method is calling Wait).
  2. Task continuations are scheduled using TaskContinuationOptions.ExecuteSynchronously.

I recommend starting with the simplest possible solution: removing the first thing (1). I.e., don’t mix async and Wait calls:

await SendAwaitResponse("first message");
SendAwaitResponse("second message").Wait();

Instead, use await consistently:

await SendAwaitResponse("first message");
await SendAwaitResponse("second message");

If you need to, you can Wait at an alternative point further up the call stack (not in an async method).

That’s my most-recommended solution. However, if you want to try removing the second thing (2), you can do a couple of tricks: either wrap the SetResult in a Task.Run to force it onto a separate thread (my AsyncEx library has *WithBackgroundContinuations extension methods that do exactly this), or give your thread an actual context (such as my AsyncContext type) and specify ConfigureAwait(false), which will cause the continuation to ignore the ExecuteSynchronously flag.

But those solutions are much more complex than just separating the async and blocking code.

As a side note, take a look at TPL Dataflow; it sounds like you may find it useful.

More Related Contents:

  1. Synchronous implementation of interface that returns Task
  2. How to limit the amount of concurrent async I/O operations?
  3. If async-await doesn’t create any additional threads, then how does it make applications responsive?
  4. What is the difference between asynchronous programming and multithreading?
  5. WaitAll vs WhenAll
  6. Catch an exception thrown by an async void method
  7. Running multiple async tasks and waiting for them all to complete
  8. Calling async method synchronously
  9. Does the use of async/await create a new thread?
  10. Why does this async action hang when I try and access the Result property of my Task?
  11. Task sequencing and re-entracy
  12. Enforce an async method to be called once
  13. How to protect resources that may be used in a multi-threaded or async environment?
  14. Cancelling a pending task synchronously on the UI thread
  15. ConfigureAwait pushes the continuation to a pool thread
  16. What thread runs the code after the `await` keyword?
  17. Executing tasks in parallel
  18. Is .GetAwaiter().GetResult(); safe for general use?
  19. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  20. A pattern for self-cancelling and restarting task
  21. What is the correct way to cancel an async operation that doesn’t accept a CancellationToken?
  22. SynchronizationLockException on Monitor.Exit when using await
  23. Converting async/await to Task.ContinueWith
  24. I thought await continued on the same thread as the caller, but it seems not to
  25. Faulted vs Canceled task status after CancellationToken.ThrowIfCancellationRequested
  26. How do I create a custom SynchronizationContext so that all continuations can be processed by my own single-threaded event loop?
  27. How to throttle multiple asynchronous tasks?
  28. The lack of non-capturing Task.Yield forces me to use Task.Run, why follow that?
  29. How to implement Task.WhenAny() with a predicate
  30. Wrapping ManualResetEvent as awaitable task

Leave a Comment