Golang如何实现跨平台文件锁 讲解flock与fcntl系统调用封装

package main

import (
    "fmt"
    "os"
    "syscall"
    "time"

    // 推荐使用这个包，它提供了更稳定的Unix系统调用封装
    "golang.org/x/sys/unix" 
)

// FlockLocker 代表一个基于flock的文件锁
type FlockLocker struct {
    file *os.File
    path string
}

// NewFlockLocker 创建一个新的FlockLocker实例
func NewFlockLocker(path string) (*FlockLocker, error) {
    // O_CREATE | O_RDWR 是为了确保文件存在且可读写，如果不存在就创建
    // 0644 是文件权限
    file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
    if err != nil {
        return nil, fmt.Errorf("无法打开或创建锁文件 %s: %w", path, err)
    }
    return &FlockLocker{file: file, path: path}, nil
}

// Lock 尝试获取排他性文件锁
func (l *FlockLocker) Lock() error {
    // unix.LOCK_EX 表示排他锁
    // unix.LOCK_NB 表示非阻塞模式，如果文件已被锁定，则立即返回错误
    // 如果需要阻塞直到获取锁，可以只用 unix.LOCK_EX
    err := unix.Flock(l.file.Fd(), unix.LOCK_EX|unix.LOCK_NB)
    if err != nil {
        if err == syscall.EWOULDBLOCK {
            return fmt.Errorf("文件已被其他进程锁定: %w", err)
        }
        return fmt.Errorf("获取文件锁失败: %w", err)
    }
    fmt.Printf("[%d] 成功获取文件锁: %s\n", os.Getpid(), l.path)
    return nil
}

// Unlock 释放文件锁
func (l *FlockLocker) Unlock() error {
    err := unix.Flock(l.file.Fd(), unix.LOCK_UN) // LOCK_UN 表示解锁
    if err != nil {
        return fmt.Errorf("释放文件锁失败: %w", err)
    }
    fmt.Printf("[%d] 成功释放文件锁: %s\n", os.Getpid(), l.path)
    return l.file.Close() // 释放锁后关闭文件
}

// 这是一个简单的使用示例，你可以运行两次看看效果
func main() {
    lockFilePath := "/tmp/my_go_flock.lock" // 锁文件路径

    locker, err := NewFlockLocker(lockFilePath)
    if err != nil {
        fmt.Println("创建锁实例失败:", err)
        return
    }

    err = locker.Lock()
    if err != nil {
        fmt.Println("获取锁失败:", err)
        // 如果是EWOULDBLOCK，说明另一个进程已经持有锁，这里可以做一些处理
        // 比如等待重试，或者直接退出
        time.Sleep(2 * time.Second) // 模拟等待
        fmt.Println("尝试再次获取锁...")
        err = locker.Lock() // 再次尝试获取
        if err != nil {
            fmt.Println("再次获取锁失败，程序退出:", err)
            return
        }
    }

    fmt.Printf("[%d] 锁已获取，正在执行一些任务...\n", os.Getpid())
    time.Sleep(5 * time.Second) // 模拟业务逻辑执行

    err = locker.Unlock()
    if err != nil {
        fmt.Println("释放锁失败:", err)
    }
    fmt.Printf("[%d] 任务完成，程序退出。\n", os.Getpid())
}

package main

import (
    "fmt"
    "os"
    "syscall"
    "time"

    "golang.org/x/sys/unix" // 再次强调，推荐使用这个包
)

// FcntlLocker 代表一个基于fcntl的文件区域锁
type FcntlLocker struct {
    file *os.File
    path string
}

// NewFcntlLocker 创建一个新的FcntlLocker实例
func NewFcntlLocker(path string) (*FcntlLocker, error) {
    // O_CREATE | O_RDWR 是为了确保文件存在且可读写
    file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
    if err != nil {
        return nil, fmt.Errorf("无法打开或创建锁文件 %s: %w", path, err)
    }
    return &FcntlLocker{file: file, path: path}, nil
}

// LockRange 尝试获取文件指定区域的排他锁
// offset: 锁定区域的起始偏移量
// length: 锁定区域的长度
func (l *FcntlLocker) LockRange(offset, length int64) error {
    fl := unix.Flock_t{
        Type:   unix.F_WRLCK,   // 排他写锁
        Whence: os.SEEK_SET,    // 从文件开头计算偏移量
        Start:  offset,
        Len:    length,
    }

    // F_SETLKW 表示阻塞式设置锁，如果锁被占用则等待
    // 如果需要非阻塞，可以使用 unix.F_SETLK
    err := unix.FcntlFlock(l.file.Fd(), unix.F_SETLKW, &fl)
    if err != nil {
        return fmt.Errorf("获取文件区域锁失败 (offset: %d, len: %d): %w", offset, length, err)
    }
    fmt.Printf("[%d] 成功获取文件区域锁: %s (offset: %d, len: %d)\n", os.Getpid(), l.path, offset, length)
    return nil
}

// UnlockRange 释放文件指定区域的锁
// offset: 锁定区域的起始偏移量
// length: 锁定区域的长度
func (l *FcntlLocker) UnlockRange(offset, length int64) error {
    fl := unix.Flock_t{
        Type:   unix.F_UNLCK,   // 解锁
        Whence: os.SEEK_SET,
        Start:  offset,
        Len:    length,
    }

    err := unix.FcntlFlock(l.file.Fd(), unix.F_SETLKW, &fl) // 解锁也用 SETLKW
    if err != nil {
        return fmt.Errorf("释放文件区域锁失败 (offset: %d, len: %d): %w", offset, length, err)
    }
    fmt.Printf("[%d] 成功释放文件区域锁: %s (offset: %d, len: %d)\n", os.Getpid(), l.path, offset, length)
    return nil
}

// Close 关闭文件描述符
func (l *FcntlLocker) Close() error {
    return l.file.Close()
}

func main() {
    lockFilePath := "/tmp/my_go_fcntl.data" // 数据文件路径

    locker, err := NewFcntlLocker(lockFilePath)
    if err != nil {
        fmt.Println("创建锁实例失败:", err)
        return
    }
    defer locker.Close() // 确保文件描述符被关闭

    // 尝试锁定文件的前10个字节
    err = locker.LockRange(0, 10)
    if err != nil {
        fmt.Println("获取区域锁失败:", err)
        return
    }

    fmt.Printf("[%d] 区域锁已获取 (0-10)，正在执行一些任务...\n", os.Getpid())
    time.Sleep(3 * time.Second) // 模拟业务逻辑执行

    // 尝试锁定文件的第20-30个字节 (可以与上面并行)
    // 在另一个进程中，你可以尝试锁定 0-10 或 5-15 来观察冲突
    err = locker.LockRange(