使用go-mysql-lock实现Golang分布式锁

分布式锁是在分布式系统中协调多个进程/服务对共享资源访问的重要机制。go-mysql-lock是一个基于MySQL实现的轻量级分布式锁库，它利用MySQL的行锁特性实现可靠的分布式锁。

安装

go get github.com/sanketplus/go-mysql-lock

基本使用

1. 初始化锁

首先需要建立MySQL连接并创建锁实例：

package main

import (
	"database/sql"
	"fmt"
	"time"

	mysqllock "github.com/sanketplus/go-mysql-lock"
	_ "github.com/go-sql-driver/mysql"
)

func main() {
	// 创建MySQL连接
	db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
	if err != nil {
		panic(err)
	}
	defer db.Close()

	// 创建锁实例
	locker := mysqllock.NewMysqlLock(db)
}

2. 获取锁

// 尝试获取名为"my_lock"的锁，设置10秒超时
lock, err := locker.Obtain("my_lock", 10*time.Second)
if err != nil {
	fmt.Printf("获取锁失败: %v\n", err)
	return
}

// 确保在函数结束时释放锁
defer lock.Release()

3. 检查锁状态

if lock.IsLocked() {
	fmt.Println("成功获取锁")
	// 执行需要锁保护的代码
} else {
	fmt.Println("未能获取锁")
}

高级用法

1. 带重试机制的锁获取

func acquireLockWithRetry(locker *mysqllock.MysqlLock, lockName string, maxRetries int) (*mysqllock.Lock, error) {
	var lock *mysqllock.Lock
	var err error
	
	for i := 0; i < maxRetries; i++ {
		lock, err = locker.Obtain(lockName, 5*time.Second)
		if err == nil {
			return lock, nil
		}
		
		time.Sleep(1 * time.Second)
	}
	
	return nil, fmt.Errorf("获取锁失败，重试%d次后放弃", maxRetries)
}

// 使用示例
lock, err := acquireLockWithRetry(locker, "important_lock", 3)
if err != nil {
	panic(err)
}
defer lock.Release()

2. 自动续期锁

func autoRenewLock(lock *mysqllock.Lock, interval time.Duration, stopChan chan struct{}) {
	ticker := time.NewTicker(interval)
	defer ticker.Stop()
	
	for {
		select {
		case <-ticker.C:
			if err := lock.Renew(); err != nil {
				fmt.Printf("续期锁失败: %v\n", err)
				return
			}
		case <-stopChan:
			return
		}
	}
}

// 使用示例
lock, err := locker.Obtain("long_running_lock", 30*time.Second)
if err != nil {
	panic(err)
}
defer lock.Release()

stopChan := make(chan struct{})
go autoRenewLock(lock, 10*time.Second, stopChan)

// 执行长时间任务
time.Sleep(2 * time.Minute)
close(stopChan)

注意事项

1. MySQL表结构：go-mysql-lock需要一个名为locks的表，结构如下：

   CREATE TABLE IF NOT EXISTS `locks` (
     `id` varchar(255) NOT NULL,
     `owner` varchar(255) NOT NULL,
     `expires_at` timestamp NOT NULL,
     PRIMARY KEY (`id`)
   ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
   

2. 性能考虑：虽然MySQL分布式锁实现简单，但在高并发场景下可能会成为性能瓶颈。

3. 锁超时：务必设置合理的锁超时时间，防止死锁。

4. 连接池：确保MySQL连接池配置合理，避免连接耗尽。

完整示例

package main

import (
	"database/sql"
	"fmt"
	"log"
	"time"

	mysqllock "github.com/sanketplus/go-mysql-lock"
	_ "github.com/go-sql-driver/mysql"
)

func main() {
	// 初始化MySQL连接
	db, err := sql.Open("mysql", "root:password@tcp(127.0.0.1:3306)/testdb")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	// 设置连接池参数
	db.SetMaxOpenConns(10)
	db.SetMaxIdleConns(5)
	db.SetConnMaxLifetime(5 * time.Minute)

	// 创建锁实例
	locker := mysqllock.NewMysqlLock(db)

	// 尝试获取锁
	lock, err := locker.Obtain("order_processing_lock", 30*time.Second)
	if err != nil {
		log.Fatalf("获取锁失败: %v", err)
	}
	defer lock.Release()

	if !lock.IsLocked() {
		log.Fatal("未能获取锁")
	}

	// 执行需要锁保护的代码
	fmt.Println("成功获取锁，开始处理订单...")
	time.Sleep(10 * time.Second)
	fmt.Println("订单处理完成")
}

go-mysql-lock提供了一种简单可靠的方式在Golang应用中实现分布式锁，特别适合已经使用MySQL作为基础设施的项目。对于更高性能要求的场景，可以考虑基于Redis或Zookeeper的分布式锁实现。