如何提升文件异步I/O效率？针对文件系统镜像提取场景

问题背景 #

从超大文件（几KiB到数GiB）按块读取数据并写入新文件，用于解析文件系统二进制镜像，调用频率极高。当前异步实现比同步版本慢至少2倍，需要优化。

原代码 #

private async Task WriteFileContentsAsync(Inode inode, FileStream outputStream)
{
    int remainder = (int)(inode.Size % BlockSize);
    remainder = (remainder == 0) ? (int)BlockSize : remainder;

    List<long> dataPointers = GetDataPointersForInode(inode);
    byte[] data = new byte[BlockSize];

    List<Task> taskList = new List<Task>();
    int i = 0;
    while (i < dataPointers.Count - 1)
    {
        FileStream.Seek(dataPointers[i], SeekOrigin.Begin);
        i++;
        taskList.Add(FileStream.ReadAsync(data, 0, (int)BlockSize));
        taskList.Add(outputStream.WriteAsync(data, 0, (int)BlockSize));
    }

    await Task.WhenAll(taskList);

    if (dataPointers.Count != 0) // handle remainder
    {
        FileStream.Seek(dataPointers[i], SeekOrigin.Begin);
        int numBytesRead = FileStream.Read(data, 0, remainder);
        if (numBytesRead == remainder)
        {
            outputStream.Write(data, 0, remainder);
        }
    }
}

补充信息 #

• 文件数据块可能连续也可能不连续（通常连续）
• BlockSize由文件系统定义，最大4KiB
• 调用前已知文件大小

原代码核心问题 #

1. 共享缓冲区导致数据混乱：所有异步读写复用同一个data数组，前一个ReadAsync还没完成，后一个ReadAsync就覆盖了缓冲区内容，WriteAsync拿到的是错误数据，同时读写完全乱序，逻辑根本错误。
2. 无限制并发：磁盘IO的并发能力有限，尤其是机械硬盘，过多并发会导致频繁寻道，反而降低效率。
3. 未利用连续块特性：连续块可以一次性读取，减少Seek和IO调用次数，原代码逐个处理块浪费性能。
4. 异步流未正确配置：如果FileStream打开时未指定异步选项，ReadAsync/WriteAsync会用同步模拟异步，反而增加开销。
5. 剩余块处理未异步：最后剩余块用同步读写，破坏异步流程的连贯性。

优化方案 #

1. 修复异步逻辑，控制并发 #

用信号量限制并发数，每个块的读写配对执行，避免数据覆盖，同时控制磁盘IO压力。

2. 利用内存池减少GC开销 #

使用ArrayPool<byte>复用缓冲区，避免频繁分配小内存块导致的GC压力，尤其适合高调用频率场景。

3. 合并连续块，减少寻道 #

检测连续的块指针，合并后一次性读取连续数据，大幅减少磁盘寻道次数（机械盘提升尤为明显）。

4. 确保FileStream异步配置 #

打开文件时必须指定异步选项：

• .NET Framework: new FileStream(path, ..., useAsync: true)
• .NET Core/.NET 5+: new FileStream(path, ..., FileOptions.Asynchronous)

优化后代码示例 #

辅助方法：合并连续块 #

// 合并连续的块指针，返回（起始位置，连续长度）
private List<(long Start, long Length)> MergeContinuousBlocks(List<long> dataPointers, int blockSize)
{
    var mergedBlocks = new List<(long, long)>();
    if (dataPointers.Count == 0)
        return mergedBlocks;

    long currentStart = dataPointers[0];
    long currentLength = blockSize;

    for (int i = 1; i < dataPointers.Count; i++)
    {
        long expectedNext = currentStart + currentLength;
        if (dataPointers[i] == expectedNext)
        {
            currentLength += blockSize;
        }
        else
        {
            mergedBlocks.Add((currentStart, currentLength));
            currentStart = dataPointers[i];
            currentLength = blockSize;
        }
    }
    mergedBlocks.Add((currentStart, currentLength));
    return mergedBlocks;
}

主异步方法 #

private async Task WriteFileContentsAsync(Inode inode, FileStream outputStream, FileStream imageStream, int maxConcurrency = 4)
{
    long totalSize = inode.Size;
    if (totalSize == 0)
        return;

    int blockSize = (int)BlockSize;
    List<long> dataPointers = GetDataPointersForInode(inode);
    var mergedBlocks = MergeContinuousBlocks(dataPointers, blockSize);
    
    // 限制并发数，机械盘建议2-4，SSD可尝试4-8
    var semaphore = new SemaphoreSlim(maxConcurrency);
    var bufferPool = ArrayPool<byte>.Shared;

    try
    {
        var tasks = new List<Task>();
        long remainingSize = totalSize;

        foreach (var block in mergedBlocks)
        {
            await semaphore.WaitAsync();
            // 处理剩余不足一个连续块的情况
            long bytesToProcess = Math.Min(block.Length, remainingSize);
            remainingSize -= bytesToProcess;

            tasks.Add(ProcessContinuousBlockAsync(imageStream, outputStream, block.Start, (int)bytesToProcess, bufferPool, semaphore));
        }

        await Task.WhenAll(tasks);
    }
    finally
    {
        semaphore.Dispose();
    }
}

// 处理单个连续块的异步读写
private async Task ProcessContinuousBlockAsync(FileStream imageStream, FileStream outputStream, long startPointer, int bytesToRead, ArrayPool<byte> bufferPool, SemaphoreSlim semaphore)
{
    byte[] buffer = null;
    try
    {
        buffer = bufferPool.Rent(bytesToRead);
        await imageStream.SeekAsync(startPointer, SeekOrigin.Begin);
        int bytesRead = await imageStream.ReadAsync(buffer.AsMemory(0, bytesToRead));
        
        if (bytesRead > 0)
        {
            await outputStream.WriteAsync(buffer.AsMemory(0, bytesRead));
        }
    }
    finally
    {
        if (buffer != null)
            bufferPool.Return(buffer);
        semaphore.Release();
    }
}

额外优化建议 #

• 调整并发数：根据磁盘类型测试最优值，机械硬盘并发过高会导致寻道开销剧增，SSD可适当提高。
• 预分配输出文件：如果已知文件大小，提前用outputStream.SetLength(totalSize)预分配空间，避免文件碎片化，提升写入效率。
• 避免不必要的异步：如果是单线程调用且磁盘IO是瓶颈，同步版本可能本来就更高效，但如果是多线程/高并发场景，优化后的异步版本会比同步更优。

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