Golang并发读写文件，sync.Mutex正确用法详解

Go的os.File类型本身不是并发安全的，多个goroutine同时读写文件会导致数据竞争或内容混乱。sync.Mutex用于保护共享资源，确保同一时间只有一个goroutine执行写操作。1. 并发写入必须加锁，否则会出现数据错乱；2. 仅并发读取可不加锁，但混合读写时需统一加锁；3. 使用sync.RWMutex可提升读性能，在有大量并发读、少量写时更高效；4. 每个文件应有独立锁，避免共用全局锁；5. 必须在操作完成后关闭文件以防止资源泄漏。正确使用锁机制能确保并发文件操作的安全与高效。

在Go语言中实现文件的并发读写时，如果没有正确的同步机制，很容易导致数据竞争或者文件内容混乱。sync.Mutex 是 Go 标准库提供的互斥锁工具，在处理多个 goroutine 同时访问共享资源（如文件）时非常有用。但要真正用好它，需要理解它的使用场景和正确方式。

为什么需要 sync.Mutex 来保护文件操作？

Go 的 os.File 类型本身不是并发安全的。如果你有多个 goroutine 同时调用 file.Write() 或者 file.Read()，可能会出现数据错乱、部分内容被覆盖等问题。

比如下面这种情况：

file, _ := os.OpenFile("log.txt", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
for i := 0; i < 10; i++ {
    go func(i int) {
        file.WriteString(fmt.Sprintf("line %d\n", i))
    }(i)
}

这段代码会创建多个 goroutine 向同一个文件追加写入内容。但由于没有加锁，最终写入的内容可能顺序错乱，甚至出现部分行被截断或重叠的情况。

这时候就需要引入 sync.Mutex 来确保同一时间只有一个 goroutine 在执行写操作。

如何正确使用 sync.Mutex 实现文件并发写入？

你需要一个全局的互斥锁变量，并在每次写入前锁定，在写完后解锁：

var mu sync.Mutex
file, _ := os.OpenFile("log.txt", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)

for i := 0; i < 10; i++ {
    go func(i int) {
        mu.Lock()
        defer mu.Unlock()
        file.WriteString(fmt.Sprintf("line %d\n", i))
    }(i)
}

这样就能保证多个 goroutine 写入时不会互相干扰。

需要注意几点：

• 锁的作用范围应该覆盖整个写操作，包括 WriteString、Write 等方法。
• 使用 defer mu.Unlock() 可以避免忘记释放锁，防止死锁。
• 如果你打开的是多个不同的文件，每个文件应有自己的锁，不要共用一个全局锁。

并发读写是否都需要加锁？

这个问题的答案取决于你具体的操作模式。

对于并发写入：必须加锁

因为多个写入源同时操作一个文件会导致不可预测的结果，所以所有写入操作都必须加锁。

对于并发读取：可以不加锁（前提是只读）

如果只是读取文件内容，并且多个 goroutine 都是“只读”操作，那通常不需要加锁。例如：

file, _ := os.Open("data.txt")
for i := 0; i < 10; i++ {
    go func() {
        buf := make([]byte, 1024)
        n, _ := file.Read(buf)
        fmt.Println(string(buf[:n]))
    }()
}

这种情况下只要不修改文件内容，就不会产生问题。

但如果存在读写混合的情况，比如有些 goroutine在读，有些在写，那就建议统一加锁，或者使用更高级的同步机制如 sync.RWMutex。

更进一步：使用 sync.RWMutex 提升读性能

如果你的应用中有大量并发读取、少量写入的需求，可以考虑使用 sync.RWMutex，它允许同时有多个读者，但在有写者时会阻塞所有读者。

示例：

var rwMu sync.RWMutex
file, _ := os.OpenFile("data.txt", os.O_CREATE|os.O_RDWR, 0644)

// 写操作
go func() {
    rwMu.Lock()
    defer rwMu.Unlock()
    file.WriteString("new content\n")
}()

// 多个读操作
for i := 0; i < 5; i++ {
    go func() {
        rwMu.RLock()
        defer rwMu.RUnlock()
        buf := make([]byte, 1024)
        n, _ := file.Read(buf)
        fmt.Println(string(buf[:n]))
    }()
}

这种方式比单纯使用 sync.Mutex 更高效，尤其在读多写少的场景下。

小贴士：别忘了关闭文件

无论你是用 os.Open 还是 os.OpenFile 打开文件，最后都要记得调用 file.Close()，否则会造成资源泄漏。

可以在打开文件之后立刻加上 defer file.Close()：

file, err := os.OpenFile("log.txt", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
if err != nil {
    log.Fatal(err)
}
defer file.Close()

基本上就这些。用好 sync.Mutex 或 sync.RWMutex，能让你的并发文件操作既安全又高效。关键在于搞清楚你的场景是纯读、纯写还是混合操作，然后选择合适的锁策略。