GO语言基础教程（230）Go文件处理之文件锁操作：Go语言文件锁揭秘：如何让你的文件不再“共享”混乱

给文件加把锁，让数据竞争不再上演

在编程世界中，文件操作就像是一个多人共享的笔记本，当多个进程或线程同时在这个笔记本上写写画画时，本子很快就会变得一团糟。Go语言中的文件锁就像是给这个笔记本加上了一把锁，确保只有一个人能在上面书写，从而避免混乱。

1. 为什么需要文件锁：当文件成了“共享笔记本”

想象一下，你和几个同事同时编辑同一个文档，没有人有锁定权限。你正在修改一段内容，同时另一个人也在编辑，最后保存的人会覆盖之前所有的更改。这种混乱的场景，在编程中就是数据竞争和一致性问题。

在多进程或多线程环境中，文件独占访问非常重要，主要原因包括：

例如，在一个日志系统中，如果多个进程同时写入一个日志文件，没有独占访问控制，日志内容会变得混乱，难以追踪和分析。

文件锁的本质是一种进程间同步机制，它就像是给文件加上了一个"请勿打扰"的牌子，告诉其他进程："我正在使用这个文件，请稍后再来"。

2. 文件锁的两种“姿势”：共享锁与独占锁

文件锁主要分为两种类型，它们像是图书馆的不同借书规则：

2.1 共享锁（Shared Lock）

也叫读锁，它允许多个进程同时读取文件，但不允许写操作。就像许多人可以同时阅读同一本书，但没有人能在上面做标记。

2.2 独占锁（Exclusive Lock）

也叫写锁，它只允许一个进程进行读写操作，其他进程无法访问该文件。这就像某人把书借走了，其他人只能等他归还后才能阅读。

在Go语言中，可以使用syscall包来调用操作系统的文件锁功能。以下是Linux和Windows系统上常用的文件锁类型及其实现方法：

3. 阻塞 vs 非阻塞：文件锁的两种“性格”

进程遇到文件锁时，有两种处理方式，这就像是你在敲门时，选择一直等待还是敲一下就走：

在Go语言中，可以通过是否添加 LOCK_NB参数来选择阻塞或非阻塞模式。例如， syscall.LOCK_SH|syscall.LOCK_NB表示非阻塞的共享锁。

4. 实战Go文件锁：给文件加上“请勿打扰”

让我们来看一个完整的Go语言文件锁示例，这个例子展示了如何给文件加上独占锁：

package main
 
import (
 "fmt"
 "os"
 "syscall"
)
 
func main() {
 filePath := "example.txt"
 file, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE, 0666)
 if err != nil {
  fmt.Println("Error opening file:", err)
  return
 }
 defer file.Close()
 
 // 加锁
 if err := syscall.Flock(int(file.Fd()), syscall.LOCK_EX); err != nil {
  fmt.Println("Error locking file:", err)
  return
 }
 defer syscall.Flock(int(file.Fd()), syscall.LOCK_UN)
 
 // 进行文件操作
 _, err = file.WriteString("Hello, World!
")
 if err != nil {
  fmt.Println("Error writing to file:", err)
  return
 }
 
 fmt.Println("File written successfully with exclusive access.")
}

这段代码做了以下几件事：

5. 跨平台解决方案：使用第三方库

Go标准库本身并没有直接提供文件锁的功能，但可以通过第三方库来实现，比如 github.com/juju/fslock包。这个包封装了底层的系统调用，使得文件锁的实现更加简单和跨平台。

以下是使用 fslock实现文件独占访问的示例：

package main
 
import (
 "time"
 "fmt"
 "github.com/juju/fslock"
)
 
func main() {
 lock := fslock.New("../lock.txt")
 lockErr := lock.TryLock()
 if lockErr != nil {
  fmt.Println("falied to acquire lock > " + lockErr.Error())
  return
 }
 
 fmt.Println("got the lock")
 time.Sleep(1 * time.Minute)
 
 // release the lock
 lock.Unlock()
}

fslock包的主要优点是跨平台一致性，它在Windows上使用 LockFileEx，在*nix系统上使用 flock。

6. 高级应用：实现一个线程安全的数据文件

现在让我们来看一个更复杂的例子，实现一个支持并发读写的数据文件结构：

package main
 
import (
 "errors"
 "io"
 "os"
 "sync"
)
 
// Data 代表数据的类型。
type Data []byte
 
// DataFile 代表数据文件的接口类型。
type DataFile interface {
 // Read 会读取一个数据块。
 Read() (rsn int64, d Data, err error)
 // Write 会写入一个数据块。
 Write(d Data) (wsn int64, err error)
 // RSN 会获取最后读取的数据块的序列号。
 RSN() int64
 // WSN 会获取最后写入的数据块的序列号。
 WSN() int64
 // DataLen 会获取数据块的长度。
 DataLen() uint32
 // Close 会关闭数据文件。
 Close() error
}
 
// myDataFile 代表数据文件的实现类型。
type myDataFile struct {
 f       *os.File     // 文件。
 fmutex  sync.RWMutex // 被用于文件的读写锁。
 woffset int64        // 写操作需要用到的偏移量。
 roffset int64        // 读操作需要用到的偏移量。
 wmutex  sync.Mutex   // 写操作需要用到的互斥锁。
 rmutex  sync.Mutex   // 读操作需要用到的互斥锁。
 dataLen uint32       // 数据块长度。
}
 
// NewDataFile 会新建一个数据文件的实例。
func NewDataFile(path string, dataLen uint32) (DataFile, error) {
 f, err := os.Create(path)
 if err != nil {
  return nil, err
 }
 if dataLen == 0 {
  return nil, errors.New("Invalid data length!")
 }
 df := &myDataFile{f: f, dataLen: dataLen}
 return df, nil
}
 
func (df *myDataFile) Read() (rsn int64, d Data, err error) {
 // 读取并更新读偏移量。
 var offset int64
 df.rmutex.Lock()
 offset = df.roffset
 df.roffset += int64(df.dataLen)
 df.rmutex.Unlock()
 
 //读取一个数据块。
 rsn = offset / int64(df.dataLen)
 bytes := make([]byte, df.dataLen)
 for {
  df.fmutex.RLock()
  _, err = df.f.ReadAt(bytes, offset)
  if err != nil {
   if err == io.EOF {
    df.fmutex.RUnlock()
    continue
   }
   df.fmutex.RUnlock()
   return
  }
  d = bytes
  df.fmutex.RUnlock()
  return
 }
}
 
func (df *myDataFile) Write(d Data) (wsn int64, err error) {
 // 读取并更新写偏移量。
 var offset int64
 df.wmutex.Lock()
 offset = df.woffset
 df.woffset += int64(df.dataLen)
 df.wmutex.Unlock()
 
 //写入一个数据块。
 wsn = offset / int64(df.dataLen)
 var bytes []byte
 if len(d) > int(df.dataLen) {
  bytes = d[0:df.dataLen]
 } else {
  bytes = d
 }
 df.fmutex.Lock()
 defer df.fmutex.Unlock()
 _, err = df.f.Write(bytes)
 return
}
 
// 其他方法实现...

这个高级示例展示了如何结合文件锁和互斥锁来实现一个完整的并发安全文件结构，它保证了多个goroutine可以安全地读写同一个文件。

7. 文件锁的注意事项：避免陷入“锁”坑

在实际应用中，文件锁的实现需要考虑多种因素：

7.1 跨平台兼容性

不同操作系统对文件锁的支持和实现机制有所不同。例如，flock和fcntl都是系统级调用，但在具体的使用上却有很大不同，并且两种锁互不干扰。

7.2 建议性锁 vs 强制性锁

7.3 错误处理

处理文件锁失败的情况，例如文件已被其他进程锁定。在非阻塞模式下，一定要检查加锁操作的返回值，并根据业务需求进行相应处理。

7.4 性能影响

文件锁可能会影响系统性能，需要根据实际需求进行优化。在高并发场景下，过于频繁的文件锁操作可能导致性能瓶颈。

7.5 锁释放

确保在进程结束或异常情况下，文件锁能够正确释放，避免死锁。在Go中，通常使用defer语句来确保锁的释放。

8. 总结：给文件加上守护锁

Go语言中的文件锁是一个强大而灵活的工具，它像是文件的守护者，确保数据在并发访问时的安全性和一致性。通过本文的介绍，你应该已经了解：

记住，文件锁虽好，但也要合理使用。过度使用文件锁可能导致性能问题，而使用不足则可能引发数据混乱。根据你的具体需求，找到平衡点才是关键。

在Go语言的并发世界中，文件锁是你工具箱中不可或缺的一员。掌握了它，你就能编写出更加健壮、可靠的并发文件操作程序，让你的数据告别"共享"混乱，迎来井然有序！