Why does this async action hang when I try and access the Result property of my Task?

by

Yep, that’s a deadlock all right. And a common mistake with the TPL, so don’t feel bad.

When you write await foo, the runtime, by default, schedules the continuation of the function on the same SynchronizationContext that the method started on. In English, let’s say you called your ExecuteAsync from the UI thread. Your query runs on the threadpool thread (because you called Task.Run), but you then await the result. This means that the runtime will schedule your “return result;” line to run back on the UI thread, rather than scheduling it back to the threadpool.

So how does this deadlock? Imagine you just have this code:

var task = dataSource.ExecuteAsync(_ => 42);
var result = task.Result;

So the first line kicks off the asynchronous work. The second line then blocks the UI thread. So when the runtime wants to run the “return result” line back on the UI thread, it can’t do that until the Result completes. But of course, the Result can’t be given until the return happens. Deadlock.

This illustrates a key rule of using the TPL: when you use .Result on a UI thread (or some other fancy sync context), you must be careful to ensure that nothing that Task is dependent upon is scheduled to the UI thread. Or else evilness happens.

So what do you do? Option #1 is use await everywhere, but as you said that’s already not an option. Second option which is available for you is to simply stop using await. You can rewrite your two functions to:

public static Task<T> ExecuteAsync<T>(this OurDBConn dataSource, Func<OurDBConn, T> function)
{
    string connectionString = dataSource.ConnectionString;

    // Start the SQL and pass back to the caller until finished
    return Task.Run(
        () =>
        {
            // Copy the SQL connection so that we don't get two commands running at the same time on the same open connection
            using (var ds = new OurDBConn(connectionString))
            {
                return function(ds);
            }
        });
}

public static Task<ResultClass> GetTotalAsync( ... )
{
    return this.DBConnection.ExecuteAsync<ResultClass>(
        ds => ds.Execute("select slow running data into result"));
}

What’s the difference? There’s now no awaiting anywhere, so nothing being implicitly scheduled to the UI thread. For simple methods like these that have a single return, there’s no point in doing an “var result = await...; return result” pattern; just remove the async modifier and pass the task object around directly. It’s less overhead, if nothing else.

Option #3 is to specify that you don’t want your awaits to schedule back to the UI thread, but just schedule to the thread pool. You do this with the ConfigureAwait method, like so:

public static async Task<ResultClass> GetTotalAsync( ... )
{
    var resultTask = this.DBConnection.ExecuteAsync<ResultClass>(
        ds => return ds.Execute("select slow running data into result");

    return await resultTask.ConfigureAwait(false);
}

Awaiting a task normally would schedule to the UI thread if you’re on it; awaiting the result of ContinueAwait will ignore whatever context you are on, and always schedule to the threadpool. The downside of this is you have to sprinkle this everywhere in all functions your .Result depends on, because any missed .ConfigureAwait might be the cause of another deadlock.

More Related Contents:

  1. How to limit the amount of concurrent async I/O operations?
  2. WaitAll vs WhenAll
  3. Catch an exception thrown by an async void method
  4. Running multiple async tasks and waiting for them all to complete
  5. Calling async method synchronously
  6. Task sequencing and re-entracy
  7. Enforce an async method to be called once
  8. Executing tasks in parallel
  9. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  10. A pattern for self-cancelling and restarting task
  11. What is the correct way to cancel an async operation that doesn’t accept a CancellationToken?
  12. Converting async/await to Task.ContinueWith
  13. How to throttle multiple asynchronous tasks?
  14. Synchronous implementation of interface that returns Task
  15. How to implement Task.WhenAny() with a predicate
  16. Calling TaskCompletionSource.SetResult in a non blocking manner
  17. An async/await example that causes a deadlock
  18. Await on a completed task same as task.Result?
  19. Async/await with/without awaiting (fire and forget)
  20. Why should I prefer single ‘await Task.WhenAll’ over multiple awaits?
  21. General purpose FromEvent method
  22. I want await to throw AggregateException, not just the first Exception
  23. What is the use for Task.FromResult in C#
  24. Different forms of the WCF service contract interface
  25. Why was “SwitchTo” removed from Async CTP / Release?
  26. Should I worry about “This async method lacks ‘await’ operators and will run synchronously” warning
  27. Faulted vs Canceled task status after CancellationToken.ThrowIfCancellationRequested
  28. How do I get a return value from Task.WaitAll() in a console app?
  29. call async method without await #2
  30. Wrapping ManualResetEvent as awaitable task

Leave a Comment