多个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
<p>import (
"io"
"os"
"time"
)</p><p>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
}</p><p>func main() {
chunks := [][]byte{
[]byte("chunk-1\n"),
[]byte("chunk-2\n"),
[]byte("chunk-3\n"),
}</p><pre class='brush:php;toolbar:false;'>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，批量刷盘降低锁争用频率。
立即学习“go语言免费学习笔记（深入）”；
- 关键点：
bufio.Writer自身不是并发安全的，所以锁要包住Write+Flush（或只在Flush时锁，但需确保 Write 不触发自动 flush） - 不要用
file.WriteString替代：它底层仍是Write，同样需要锁 - 慎用
os.O_APPEND：Linux 下它保证每次write(2)原子追加，但 Go 的bufio.Writer会缓存并分多次系统调用，无法依赖该标志实现并发安全
package main
<p>import (
"bufio"
"os"
"sync"
)</p><p>type SafeWriter struct {
writer *bufio.Writer
mu sync.Mutex
}</p><p>func NewSafeWriter(f <em>os.File) </em>SafeWriter {
return &SafeWriter{
writer: bufio.NewWriter(f),
}
}</p><p>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() // 强制刷盘，避免缓存堆积
}</p><p>func main() {
f, _ := os.OpenFile("shared.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
defer f.Close()</p><pre class='brush:php;toolbar:false;'>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") }，避免阻塞 - 该模式本质是把并发写转为「并发生产 + 单线程消费」，适合日志、指标采集等场景
真正容易被忽略的是：文件系统本身对小写入的吞吐限制。无论用哪种方式，并发写入大量小块（
