IAsyncDisposable实现疑问：调用Dispose(false)引发堆损坏问题

核心问题 #

你碰到的0xC0000374堆损坏错误，核心原因是同步释放和异步释放逻辑重复释放了同一个非托管指针。微软文档里提到的Dispose(false)调用，是针对传统Dispose(bool disposing)模式中终结器的调用路径，不是让DisposeAsync()直接去调用的——如果你的同步Dispose()已经完成了非托管资源的释放，异步方法再调用Dispose(false)就会触发重复释放，直接破坏堆结构。

当前实现的典型错误 #

1. 错误复用同步释放分支：如果你的Dispose(bool disposing)里，disposing=false分支负责释放非托管资源，而同步Dispose()已经通过Dispose(true)间接调用过这个分支（或者直接在同步方法里释放了非托管资源），那DisposeAsync()再调用Dispose(false)必然导致重复释放。
2. Disposed状态判断存在竞态：如果只是用普通布尔变量做判断，多线程场景下可能出现“一个线程刚判断完未释放，另一个线程已经完成释放并修改状态”的情况，导致当前线程还是执行了释放操作。
3. 异步释放逻辑设计偏差：实现IAsyncDisposable时，不能直接照搬同步Dispose(bool)的逻辑。如果你的非托管资源只能同步释放，DisposeAsync()应该在异步上下文里执行同步释放，但要确保只执行一次；如果有异步可释放资源，要单独处理。

正确实现方式 #

针对纯同步非托管资源的异步释放 #

如果你的NativeMemory只管理同步释放的非托管资源，参考这个实现：

private IntPtr _nativePtr;
private int _disposed; // 用int做原子操作，比bool更可靠

public async ValueTask DisposeAsync()
{
    // 原子操作确保释放逻辑只执行一次
    if (Interlocked.Exchange(ref _disposed, 1) == 1)
        return;

    // 在Task.Run里执行同步释放，避免阻塞调用线程
    await Task.Run(() =>
    {
        if (_nativePtr != IntPtr.Zero)
        {
            Marshal.FreeHGlobal(_nativePtr);
            _nativePtr = IntPtr.Zero;
        }
    });

    GC.SuppressFinalize(this);
}

public void Dispose()
{
    if (Interlocked.Exchange(ref _disposed, 1) == 1)
        return;

    if (_nativePtr != IntPtr.Zero)
    {
        Marshal.FreeHGlobal(_nativePtr);
        _nativePtr = IntPtr.Zero;
    }

    GC.SuppressFinalize(this);
}

// 终结器（如果需要）
~NativeMemory()
{
    Dispose(false);
}

private void Dispose(bool disposing)
{
    if (_disposed != 0)
        return;

    if (disposing)
    {
        // 释放托管资源（如果有）
    }

    if (_nativePtr != IntPtr.Zero)
    {
        Marshal.FreeHGlobal(_nativePtr);
        _nativePtr = IntPtr.Zero;
    }

    _disposed = 1;
}

含异步可释放资源的场景 #

如果有真正的异步资源（比如异步IO句柄），分开处理同步和异步释放：

private IntPtr _nativePtr;
private IAsyncDisposable? _asyncResource;
private int _disposed;

public async ValueTask DisposeAsync()
{
    if (Interlocked.Exchange(ref _disposed, 1) == 1)
        return;

    // 优先释放异步资源
    if (_asyncResource != null)
    {
        await _asyncResource.DisposeAsync();
        _asyncResource = null;
    }

    // 再释放非托管资源
    if (_nativePtr != IntPtr.Zero)
    {
        Marshal.FreeHGlobal(_nativePtr);
        _nativePtr = IntPtr.Zero;
    }

    GC.SuppressFinalize(this);
}

public void Dispose()
{
    if (Interlocked.Exchange(ref _disposed, 1) == 1)
        return;

    // 同步释放异步资源（如果支持同步释放）
    (_asyncResource as IDisposable)?.Dispose();
    _asyncResource = null;

    // 释放非托管资源
    if (_nativePtr != IntPtr.Zero)
    {
        Marshal.FreeHGlobal(_nativePtr);
        _nativePtr = IntPtr.Zero;
    }

    GC.SuppressFinalize(this);
}

关键注意点 #

• 用原子操作保证线程安全：Interlocked.Exchange可以避免多线程下的竞态条件，确保释放逻辑只执行一次，普通布尔变量做不到这点。
• 终结器只调用一次：Dispose(false)是给终结器用的，异步释放逻辑不要直接调用这个分支，避免和同步释放、终结器的释放逻辑冲突。
• 释放后清空指针：释放非托管资源后一定要把指针设为IntPtr.Zero，防止后续代码误判指针有效导致重复操作。

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