Why does an async Task.Run terminate a Thread and a Task Run does not?

Question

I am starting a Thread where an await Task.Run can be invoked.

After starting a Thread with the ThreadStart.Start method, why does the await Task.Run terminate the Thread and Task.Run does not?

Here is some code as an example:

public async Task Task1()
{
    if (awaitRunTask)
    {
        await Task.Run(async () =>
        {
            await Test();
        }
        );
    }
    else
    {
        Task.Run(async () =>
        {
            await Test();
        }
        );
    }
}

In the above example, if a Thread invokes the Task1 method, and awaitRunTask = true, the Thread terminates. If awaitRunTask = false, the Thread does not terminate.

When I say terminate, the Thread does not complete correctly and the method where the ThreadStart.Start is invoked returns. This happens at the await Test() code.

Why is this and if I want to await a Task.Run on a Thread, is there a way to do this?

EDIT

Here is some code to show a more detailed example:

public class ThreadExample
{
    public bool awaitRunTask;
    public string value;
    private async Task StartThreadAsync()
    {
        var method = this.GetType().GetMethod("RunTasksAsync");
        ThreadStart threadStart;
        threadStart = async () =>
        {
            await InvokeAsync(method, this, null);
        };
        var thread = new Thread(threadStart);
        thread.Start();
        thread.Join();
    }
    public async Task RunTasksAsync()
    {
        await Task1Async();
        Task2();
    }
    private async Task Task1Async()
    {
        if (awaitRunTask)
        {
            await Task.Run(async () =>
            {
                await TestAsync();
            }
            );
        }
        else
        {
            Task.Run(async () =>
            {
                await TestAsync();
            }
            );
        }
    }
    private void Task2()
    {
        value = "valid";
    }
    private async Task TestAsync()
    {
        await Task.Delay(1000);
    }
    private async Task InvokeAsync(MethodInfo method, object instance, object[] parameters)
    {
        dynamic awaitable = method.Invoke(instance, parameters);
        await awaitable;
    }
    public async Task ValueIsCorrectAsync()
    {
        value = "not valid";
        awaitRunTask = false;
        await StartThreadAsync();
        var isCorrect = (value == "valid");
    }
    public async Task ValueIsNotCorrectAsync()
    {
        value = "not valid";
        awaitRunTask = true;
        await StartThreadAsync();
        var isCorrect = (value == "valid");
    }
}

The ValueIsCorrectAsync method works correctly as the Task2 method sets the value field.

The ValueIsNotCorrectAsync method does not work correctly as the await Task.Run in the Task1Async method interferes with the Thread. The StartThreadAsync method returns before the Task2 method sets the value field.

The only difference between the two methods, is the value of awaitRunTask.

How should I change my code such that the value field is set correctly when awaitRunTask = true?

EDIT3

If the await Task.Delay(1000); is commented out in the TestAsync method, the code works for both awaitRunTask = true and awaitRunTask = false;

Can someone please explain to me why? I need to know why because the TestAsync method needs to be able to run asynchronous code.

Answer 1

Why is this?

As I explain on my blog, await here is actually returning to its caller. So the Task1 method returns an incomplete task to its caller, presumably the thread's main method, which presumably is async void. When the thread's main method returns (due to it's await), the thread exits.

The core of the problem is that the Thread type doesn't understand or work naturally with asynchronous code. Thread is really a very low-level building block at this point and is best avoided in modern code. There are very few scenarios where it can't be replaced with Task.Run.

if I want to await a Task.Run on a Thread, is there a way to do this?

The easiest solution is to get rid of the legacy thread completely; replace it with Task.Run.

Otherwise, you need the thread to block. If the continuations can run on thread pool threads, then you can just block directly (e.g., GetAwaiter().GetResult()). If the continuations need to run on that thread, then use AsyncContext from my AsyncEx library.

Answer 2

Here's a minimal version of your sample code:

async Task Main()
{
    var te = new ThreadExample();
    await te.StartThreadAsync(false);
    await te.StartThreadAsync(true);
}

public class ThreadExample
{
    public string value;
    public async Task StartThreadAsync(bool awaitRunTask)
    {
        value = "not valid";
        var thread = new Thread(() => Task1Async(awaitRunTask));
        thread.Start();
        thread.Join();
        var isCorrect = (value == "valid");
        Console.WriteLine(isCorrect);
    }

    private async Task Task1Async(bool awaitRunTask)
    {
        if (awaitRunTask)
        {
            await Task.Run(async () => await Task.Delay(1000));
        }
        value = "valid";
    }
}

This outputs:

True
False

The thread that enters Task1Async executes the line value = "valid" when awaitRunTask == false, but when it's true it hits the await Task.Run and, because of the async state machine, the thread returns to the caller at this point and executes the thread.Join().

Effectively you've created an extreme race condition.