Golang并发写入文件方法与技巧

在Go语言中，多个goroutine直接并发写入同一文件会导致数据错乱、丢失甚至panic，根本原因在于*os.File.Write非线程安全，存在文件偏移量和缓冲区竞争；本文深入剖析问题本质，并给出三种实用解决方案：最推荐各goroutine写入独立文件后合并（无锁、可扩展、易调试），次选加锁+缓冲写入（sync.Mutex配合bufio.Writer降低锁粒度），以及高并发场景下的channel队列模式（单writer消费，彻底解耦生产与写入），辅以可运行代码示例和关键避坑提示，助你写出高效、健壮、真正并发安全的文件写入逻辑。

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学习网公众号，带你了解更多关于的知识点！