Swift中增量写入大文本文件的性能问题及优化方案问询

问题背景 #

在写入大体积ASCII文本文件时，我发现增量写入方式速度极慢且内存占用极高。测试参数size=10_000_000时：

• 增量写入（writeFileIncrementally）耗时20-25秒，内存增长至GiB级别
• 一次性写入（writeFileFromBigData）仅需1-1.5秒，速度是增量写入的20倍

对比Python实现，其增量写入仅耗时2.7秒且内存占用恒定，差异显著。

Swift测试代码 #

func writeFileIncrementally(toUrl url: URL, size: Int) {
    // ensure file exists and is empty
    try? "".write(to: url, atomically: true, encoding: .ascii)
    
    guard let handle = try? FileHandle(forWritingTo: url) else {return}
    
    defer {
        handle.closeFile()
    }
    
    for i in 0..<size {
        let s = "\(i)\n"
        handle.write(s.data(using: .ascii)!)
    }
}

func writeFileFromBigData(toUrl url: URL, size: Int) {
    let s = (0..<size).map{String($0)}.joined(separator: "\n")
    
    try? s.write(to: url, atomically: true, encoding: .ascii)
}

Python测试代码 #

def writeFileIncrementally(path, size):
    with open(path, "w+") as f:
        for i in range(size):
            f.write(f"{i}\n")

def writeFileFromBigData(path, size):
    with open(path, "w+") as f:
        f.write("\n".join(str(i) for i in range(size)))

问题1：为何Swift增量写入速度慢且内存占用高？ #

核心原因有三点：

1. 无缓冲的小批量系统调用：Python文件对象默认启用缓冲区，小批量写入会先攒到阈值再触发磁盘IO；而Swift的FileHandle.write(_:)直接调用底层系统write函数，无额外缓冲。循环中每次写入几字节的小数据，会产生百万级系统调用，大幅拖慢速度，同时操作系统的页缓存机制会堆积大量小数据块，导致内存飙升。
2. 重复的临时对象开销：循环内每次创建"\(i)\n"字符串、调用data(using: .ascii)转换为Data，会生成大量临时对象，增加内存分配和垃圾回收的负担，进一步拉高内存占用。
3. 初始文件创建的额外开销：用"".write(to: url, atomically: true...)创建空文件时，atomically参数会触发临时文件写入+替换的流程，多一次不必要的IO操作；且无需先写入空字符串，直接用FileHandle的写入模式即可创建新文件。

问题2：Swift中更优的增量写入方案 #

以下方案可兼顾速度与内存占用：

方案1：手动实现缓冲区 #

维护固定大小的内存缓冲区，攒够数据后批量写入磁盘，减少系统调用次数：

func writeFileWithBuffer(toUrl url: URL, size: Int, bufferSize: Int = 1024 * 64) {
    // 直接创建/截断目标文件，避免原子写入的额外开销
    try? FileManager.default.createFile(atPath: url.path, contents: nil, attributes: nil)
    guard let handle = try? FileHandle(forWritingTo: url) else { return }
    defer { handle.closeFile() }
    
    var buffer = Data(capacity: bufferSize)
    for i in 0..<size {
        // 直接追加UTF8数据（ASCII兼容）到缓冲区
        buffer.append("\(i)\n".utf8)
        // 缓冲区达到阈值时写入磁盘并复用内存空间
        if buffer.count >= bufferSize {
            handle.write(buffer)
            buffer.removeAll(keepingCapacity: true)
        }
    }
    // 写入缓冲区剩余数据
    if !buffer.isEmpty {
        handle.write(buffer)
    }
}

方案2：使用OutputStream #

OutputStream自带缓冲机制，比手动维护缓冲区更简洁：

func writeFileWithOutputStream(toUrl url: URL, size: Int) {
    guard let outputStream = OutputStream(url: url, append: false) else { return }
    outputStream.open()
    defer { outputStream.close() }
    
    let bufferSize = 1024 * 64
    var buffer = Data(capacity: bufferSize)
    for i in 0..<size {
        buffer.append("\(i)\n".utf8)
        if buffer.count >= bufferSize {
            _ = buffer.withUnsafeBytes {
                outputStream.write($0.baseAddress!.assumingMemoryBound(to: UInt8.self), maxLength: $0.count)
            }
            buffer.removeAll(keepingCapacity: true)
        }
    }
    // 写入剩余数据
    if !buffer.isEmpty {
        _ = buffer.withUnsafeBytes {
            outputStream.write($0.baseAddress!.assumingMemoryBound(to: UInt8.self), maxLength: $0.count)
        }
    }
}

额外优化点 #

如果要进一步降低开销，可替换字符串转换逻辑：比如用更高效的数字转字符串方法（如底层优化的String.init(_:)实现），或直接操作UTF8视图避免重复的Data转换，不过上述两种方案已能将增量写入速度提升至接近一次性写入的水平。

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