Golang并发写入文件方法解析

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《Golang并发写入文件技巧分享》，这篇文章主要讲到等等知识，如果你对Golang相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

多个goroutine直接并发写同一*os.File会导致数据错乱或丢失，因底层文件偏移量和缓冲区竞争；推荐方案是各goroutine写独立文件后合并，或用sync.Mutex+bufio.Writer加锁缓冲写入，或通过channel由单goroutine消费写入。

goroutine 写文件时为什么会出现数据错乱或丢失

多个 goroutine 直接对同一个 *os.File 调用 Write 或 WriteString，会因底层共享的文件偏移量（offset）和缓冲区竞争导致写入覆盖、顺序错乱或 panic。Go 的 os.File.Write 不是线程安全的——它不保证原子性，也不自动加锁。

• 典型现象：write /path/to/file: bad file descriptor（文件被提前关闭）、内容重复、长度不对、部分 goroutine 写入无声失败
• 根本原因：多个 goroutine 并发调用 file.Write() 时，系统调用 write(2) 的返回值不可预测，且 Go 标准库未在 *os.File 层做同步
• 不是“加个 sync.Mutex 就万事大吉”：即使加锁，若所有 goroutine 都争抢同一把锁写入同一文件，实际变成串行，失去并发意义

推荐方案：每个 goroutine 写独立文件 + 合并（适合日志/批量导出）

最稳妥、可扩展性强的方式是避免共享文件句柄。让每个 goroutine 持有自己打开的文件，写完后由主协程统一合并。适用于「按批次生成文件」场景（如导出用户数据分片）。

• 优点：无锁、无竞争、易于 debug、支持失败重试与进度追踪
• 注意点：需确保文件名唯一（可用 uuid.NewString() 或 time.Now().UnixNano()），否则多个 goroutine 可能覆盖彼此文件
• 合并时建议用 io.Copy 而非逐行读取拼接，减少内存压力

package main
import (
"io"
"os"
"time"
)
func writeChunk(filename string, data []byte) error {
f, err := os.Create(filename)
if err != nil {
return err
}
defer f.Close()
_, err = f.Write(data)
return err
}
func main() {
chunks := [][]byte{
[]byte("chunk-1\n"),
[]byte("chunk-2\n"),
[]byte("chunk-3\n"),
}
done := make(chan error, len(chunks))
for i, chunk := range chunks {
    go func(idx int, d []byte) {
        name := "output_" + string(rune('a'+idx)) + "_" + time.Now().Format("150405") + ".txt"
        done <- writeChunk(name, d)
    }(i, chunk)
}

// 等待全部完成
for i := 0; i < len(chunks); i++ {
    if err := <-done; err != nil {
        panic(err)
    }
}

// 合并（示例：追加到 final.txt）
out, _ := os.OpenFile("final.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
defer out.Close()
for i := 0; i < len(chunks); i++ {
    name := "output_" + string(rune('a'+i)) + "_" + time.Now().Format("150405") + ".txt"
    in, _ := os.Open(name)
    io.Copy(out, in)
    in.Close()
    os.Remove(name) // 清理临时文件
}
}

必须共享文件时：用 sync.Mutex + bufio.Writer 缓冲写入

若业务强制要求所有 goroutine 往同一个文件追加（例如中心化日志），必须加锁，但不能每次 Write 都锁整个系统调用。应封装带锁的 bufio.Writer，批量刷盘降低锁争用频率。

• 关键点：bufio.Writer 自身不是并发安全的，所以锁要包住 Write + Flush（或只在 Flush 时锁，但需确保 Write 不触发自动 flush）
• 不要用 file.WriteString 替代：它底层仍是 Write，同样需要锁
• 慎用 os.O_APPEND：Linux 下它保证每次 write(2) 原子追加，但 Go 的 bufio.Writer 会缓存并分多次系统调用，无法依赖该标志实现并发安全

package main
import (
"bufio"
"os"
"sync"
)
type SafeWriter struct {
writer *bufio.Writer
mu     sync.Mutex
}
func NewSafeWriter(f os.File) SafeWriter {
return &SafeWriter{
writer: bufio.NewWriter(f),
}
}
func (sw *SafeWriter) WriteLine(s string) error {
sw.mu.Lock()
defer sw.mu.Unlock()
_, err := sw.writer.WriteString(s + "\n")
if err != nil {
return err
}
return sw.writer.Flush() // 强制刷盘，避免缓存堆积
}
func main() {
f, _ := os.OpenFile("shared.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
defer f.Close()
sw := NewSafeWriter(f)
for i := 0; i < 10; i++ {
    go func(id int) {
        sw.WriteLine("log from goroutine " + string(rune('0'+id)))
    }(i)
}

// 简单等待（实际应使用 sync.WaitGroup）
time.Sleep(time.Millisecond * 10)
}

更高级替代：用 chan []byte 做写入队列

当写入频率高、goroutine 数量多，且对延迟敏感时，直接锁文件仍可能成为瓶颈。此时可引入单 writer goroutine 消费 channel，其他 goroutine 只负责发数据——解耦生产与消费，天然避免竞争。

• channel 容量需设限（如 make(chan []byte, 1000)），防止 OOM
• 发送方应处理 select { case ch <- data: ... default: log.Warn("drop log") }，避免阻塞
• 该模式本质是把并发写转为「并发生产 + 单线程消费」，适合日志、指标采集等场景

真正容易被忽略的是：文件系统本身对小写入的吞吐限制。无论用哪种方式，并发写入大量小块（

以上就是《Golang并发写入文件方法解析》的详细内容，更多关于的资料请关注golang学习网公众号！