为何在async void方法中Fire and Forget socket.Listen()会导致XUnit死锁？

问题背景 #

我遇到了一个无法理解的异常现象，以下是简化后的问题代码：

using Xunit;
using System.Net;
using System;
using System.Net.Sockets;
using System.Threading.Tasks;

#if NET6_0_OR_GREATER

namespace Tests
{
    // 避免套接字测试并行执行
    [Collection("SocketTests")]
    public class TestDeadlock : IDisposable
    {
        private readonly Socket _socket;
        private bool _disposed;

        public TestDeadlock()
        {
            _socket = new Socket(SocketType.Stream, ProtocolType.IP);
            _socket.Bind(new IPEndPoint(IPAddress.Loopback, 10000));
            _socket.Listen();
        }

        // 在我的代码中，这个方法是由测试库实例化并销毁的对象的方法
        private async void Listen()
        {
            var client = await _socket.AcceptAsync();
        }
        
        [Fact]
        public void GoDeadLock()
        {
            Listen();
            Assert.True(true);
        }

        // 这个方法不会导致测试死锁
        private async Task ListenNoDeadLock()
        {
            var client = await _socket.AcceptAsync();
        }
        
        [Fact]
        public void WorkButGivesWarning()
        {
            ListenNoDeadLock(); // 未等待Task => 编译器警告
            Assert.True(true);
        }

        protected virtual void Dispose(bool disposing)
        {
            // 永远不会执行到这里。XUnit在Fact方法退出后就阻塞了
            if (!_disposed)
            {
                if (disposing)
                {
                    _socket.Dispose();
                }

                _disposed = true;
            }
        }

        public void Dispose()
        {
            // 不要修改此代码。清理代码放在 'Dispose(bool disposing)' 方法中
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }
    }
}

#endif

运行GoDeadLock测试时，测试完成后会发生死锁，永远无法进入TestDeadLock.Dispose()方法。如果在测试中使用using语句则无问题，但我希望复用Dispose()和对象初始化逻辑。

不过，若将Listen方法从async void改为async Task（仍采用Fire and Forget方式），测试就能正常运行！但我不希望该方法返回Task，只想让它在后台启动异步操作，且认为使用Task.Run会浪费线程。

请问该现象的原因是什么？有没有更简洁的实现方式？

编辑：
我找到了一种更合理的Fire and Forget实现，能处理异常且不会导致XUnit死锁：

// 更优的解决方案
private void GoodFireAndForget()
{
    Task.Run( async () => 
    {
        var client = await _socket.AcceptAsync();

    }).ContinueWith((task) =>
    {
        task.Exception.Handle((e) =>
            {
                // 处理异常
                return true;
            });
    }, TaskContinuationOptions.OnlyOnFaulted);
}

[Fact]
public void WorksAndSeemsTheGoodWay()
{
    GoodFireAndForget();
    Assert.True(true);
}

原因分析 #

• Async Void的特殊生命周期：async void是专门为传统事件处理设计的语法，它的执行逻辑和async Task完全不同。XUnit的测试运行时会追踪所有async void方法的执行，并且会等待这些方法完成后才会继续执行后续的清理逻辑（比如Dispose）。而AcceptAsync会一直阻塞等待客户端连接，导致测试运行时永远卡在等待这个async void方法结束的状态，进而无法进入Dispose流程。
• Async Task的行为差异：对于async Task方法，即使你以Fire and Forget的方式调用（不await），XUnit不会强制等待这个未被追踪的Task完成——只会给出编译器警告。所以测试方法执行完Assert后就会直接进入Dispose阶段，不会被未完成的异步操作阻塞。

解决方案 #

1. 优化Fire and Forget实现（推荐） #

你找到的Task.Run结合ContinueWith的方案已经很合理，这里可以优化异常处理的可读性，同时明确忽略返回的Task（用_ =避免编译器警告）：

private void SafeFireAndForget()
{
    _ = Task.Run(async () =>
    {
        var client = await _socket.AcceptAsync();
        // 这里添加客户端连接的处理逻辑
    }).ContinueWith(task =>
    {
        if (task.Exception != null)
        {
            foreach (var ex in task.Exception.InnerExceptions)
            {
                // 替换为实际的异常日志或处理逻辑
                Console.WriteLine($"异步监听操作抛出异常：{ex.Message}");
            }
        }
    }, TaskContinuationOptions.OnlyOnFaulted);
}

关于Task.Run是否浪费线程的疑问

Task.Run确实会将任务调度到线程池，但AcceptAsync是IO绑定操作——await之后，线程会被立即释放回线程池，直到套接字收到新连接时才会重新占用线程。这种方式不会造成线程浪费，反而能正确规避async void带来的死锁问题，同时还能统一处理异步操作的异常。

2. 利用取消令牌终止异步操作 #

如果不想使用Task.Run，可以通过取消令牌让AcceptAsync提前结束，从而让async void方法正常完成：

private readonly Socket _socket;
private readonly CancellationTokenSource _cts;
private bool _disposed;

public TestDeadlock()
{
    _socket = new Socket(SocketType.Stream, ProtocolType.IP);
    _socket.Bind(new IPEndPoint(IPAddress.Loopback, 10000));
    _socket.Listen();
    _cts = new CancellationTokenSource();
}

private async void Listen()
{
    try
    {
        // 使用带取消令牌的AcceptAsync重载
        var client = await _socket.AcceptAsync(_cts.Token);
        // 处理客户端连接逻辑
    }
    catch (OperationCanceledException)
    {
        // 预期的取消异常，无需额外处理
    }
    catch (Exception ex)
    {
        // 处理其他异常
    }
}

protected virtual void Dispose(bool disposing)
{
    if (!_disposed)
    {
        if (disposing)
        {
            // 取消异步操作
            _cts.Cancel();
            _cts.Dispose();
            _socket.Dispose();
        }
        _disposed = true;
    }
}

当测试进入Dispose阶段时，取消令牌会触发AcceptAsync抛出OperationCanceledException，async void方法捕获异常后正常结束，测试运行时就能顺利完成清理流程。

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