.NET中Thread.Join()为何在线程未终止时提前返回？

核心问题：async void与Thread类的不兼容 #

你的问题本质是将async void方法作为Thread的入口函数导致的异常行为，这是.NET异步编程模型与传统Thread类的典型冲突点：

1. Thread.Join提前返回的原因 #

当调用Thread.Start执行async void方法时：

• 方法执行到第一个await（此处为await ReceiveIncomingMessageAsync()）时，会释放当前线程回到线程池，此时Thread对象会判定线程已执行完毕，将IsAlive标记为false。
• 后续的WebSocket收发等异步逻辑会由线程池中的其他线程继续执行，但原Thread实例已处于终止状态，因此Thread.Join()会提前返回。

2. ThreadState误报Stopped的原因 #

Thread对象仅跟踪最初启动的那个线程，当async void方法在await后切换到其他线程池线程时，原线程已经退出，Thread.ThreadState自然显示为Stopped。但WebSocket的收发逻辑是在异步任务链中持续执行，并非依赖原线程，所以会出现"线程状态显示停止但实际逻辑仍在运行"的矛盾现象。

3. 与PONG消息的关联 #

你观察到的PONG消息时间巧合，本质是PONG触发的WebSocket IO操作刚好是某次await恢复的时机，只是表象，并非问题根源。

修复方案 #

放弃用Thread类托管异步逻辑，改用.NET异步编程模型的Task来管理：

1. 重构线程入口为async Task #

将async void方法改为async Task，避免异步逻辑脱离跟踪：

private async Task HandleIncomingMessagesAsync()
{
    try
    {
        Console.WriteLine("PapiClient HandleIncomingMessages starting");

        do
        {
            try
            {
                Message? message = await ReceiveIncomingMessageAsync();
                // 优先将HandleIncomingMessage改为异步方法，减少线程池开销
                _ = HandleIncomingMessageAsync(message);
            }
            catch (OperationCanceledException)
            {
                break;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Exception while handling messages: {ex}");
            }
        } while (!_cancellationToken.IsCancellationRequested && Connected);
    }
    catch (ObjectDisposedException) { }
    finally
    {
        _messagingComplete.Set();
        Console.WriteLine(
            $"PapiClient HandleIncomingMessages finishing: cancel={_cancellationToken.IsCancellationRequested}, connected={Connected}"
        );
    }
}

// 同理修改HandleOutgoingMessages为async Task方法

2. 用Task替代Thread管理异步任务 #

// 替换原Thread对象为Task
private Task _incomingMessageTask;
private Task _outgoingMessageTask;

// 初始化时启动异步任务
_incomingMessageTask = HandleIncomingMessagesAsync();
_outgoingMessageTask = HandleOutgoingMessagesAsync();

3. 正确等待异步任务完成 #

修改阻塞等待逻辑，使用Task.WaitAll或await（若主线程支持异步）：

public void BlockUntilThreadsAreDone()
{
    try
    {
        // 等待两个异步任务完成，支持取消令牌
        Task.WaitAll(_incomingMessageTask, _outgoingMessageTask, _cancellationToken);
    }
    catch (OperationCanceledException)
    {
        // 处理取消逻辑
    }
}

// 若主线程支持异步，更推荐用await：
public async Task BlockUntilThreadsAreDoneAsync()
{
    await Task.WhenAll(_incomingMessageTask, _outgoingMessageTask);
}

额外优化点 #

• 避免用Task.Run包裹同步方法，若HandleIncomingMessage耗时较长，建议直接改为异步方法，减少线程池资源消耗。
• 确保Connected状态的更新是线程安全的，避免异步逻辑中出现状态不一致。

内容的提问来源于stack exchange，提问作者Matt