多个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 mainimport ( "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 zuojiankuohaophpcn- writeChunk(name, d) }(i, chunk) } // 等待全部完成 for i := 0; i zuojiankuohaophpcn len(chunks); i++ { if err := zuojiankuohaophpcn-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 zuojiankuohaophpcn 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 mainimport ( "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 zuojiankuohaophpcn 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 ，避免阻塞 - 该模式本质是把并发写转为「并发生产 + 单线程消费」，适合日志、指标采集等场景
真正容易被忽略的是：文件系统本身对小写入的吞吐限制。无论用哪种方式，并发写入大量小块（
