CODEWITHSUNDEEP
c#async-awaittask-parallel-library
Intruder
Intruder

Reputation: 145

async wait leading to deadlock

I have an async codeblock running on the pageload. The codes run smoothy until you reach capturevalue method where we create a new task.On executing that code block the await just freezes and then the control doesnt come back seems like the code just went to deadlock 

 protected void Page_Load(object sender, EventArgs e)
    {
        try
        {
            var textvalue = GetTextValueFromTask();
            txtbox.Text = textvalue.Result;
            string ss = "";
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }

    private async Task<string> GetTextValueFromTask()
    {
        string strReturn = await CaptureValue();
        return strReturn;
    }

    private async Task<string> CaptureValue()
    {
        Thread.Sleep(5000);
        Task<string> T = Task.Factory.StartNew<string>(() => "hi");
        return await T;
    }

Then I made a small change in Capturevalue method.

private async Task<string> CaptureValue()
    {
        Thread.Sleep(5000);
        Task<string> T = Task.Factory.StartNew<string>(() => "hi");
        string ss = T.Result;
        return await T;
    }

Once I made that change it started working normal.What difference did it make on just fetching the result initially. Please help me Iam a newbee to async

Upvotes: 2

Views: 798

Answers (2)

Dmytro Marchuk
Dmytro Marchuk

Reputation: 476

The difference is that second time it doesn't happen any "await" because you waited the task yourself, so await doesn't do anything. I think you missed the await keyword the first time, here:

var textvalue = await GetTextValueFromTask();

Without it your method GetTextValueFromTask runs synchronously, then it comes into CaptureValue method where await occurs. But the default behaviour of the await is that it tries to capture synchronization context where it was called and to continue the rest of the method in that context, in your example it is WPF synchronization context, which does not allow more than one thread to execute at once. But the continuation cannot proceed, because context is already used by await mechanism.

So, one more time. There is one thread (UI thread), that executes your code up to the last await, which is return await T;, then it yields back to the caller - GetTextValueFromTask, and again to the Page_Load when it gets blocked, because initially you called GetTextValueFromTask synchronously (without await). After that, your operation T completes, and your code tries to continue executing using the initial synchronization context, the WPF one. But it can't, because it is already waiting in the Page_Load.

The link in the comments describes the situation in more detail.

Also consider not using Thread.Sleep in async/await scenarios, because it kills all the "asynchronous" nature of the code. Further reading: link.

Another general piece of advice, which is not directly applicable to your source code, is not to use Task.Factory.StartNew, but rather use Task.Run. Explanation here.

Upvotes: 1

Larry
Larry

Reputation: 18031

Please use Task.Run() instead of Task.Factory.StartNew()

var T = Task.Run(() => "hi");

It's up to Task.Run to decide how to handle this task.

Also please use .ConfigureAwait(false) in your await calls that do not requires the continuation being done in the awaiter thread context.

Upvotes: 1

Related Questions