Go使用Redis实现分布式锁的常见方法_Golang

实现分布式锁的方法

使用 redis 的 set 命令

redis 的 set 命令支持设置键值对，并且可以通过 nx 和 ex 参数来实现原子性操作，从而实现分布式锁。

nx：只有当键不存在时，才设置键。
ex：设置键的过期时间（秒）。

示例代码

以下是一个使用 go 和 redis 实现分布式锁的示例代码：

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/go-redis/redis/v8"
)

var ctx = context.background()

func main() {
	// 初始化 redis 客户端
	rdb := redis.newclient(&redis.options{
		addr:     "localhost:6379", // redis 地址
		password: "",               // 密码
		db:       0,                // 数据库编号
	})

	// 锁的键名和超时时间
	key := "my_lock"
	timeout := time.second * 10

	// 尝试获取锁
	lockacquired := acquirelock(ctx, rdb, key, timeout)
	if lockacquired {
		defer releaselock(ctx, rdb, key)

		// 在这里执行需要加锁的操作
		fmt.println("lock acquired, performing critical section operations...")
		time.sleep(time.second * 5) // 模拟耗时操作
		fmt.println("critical section operations completed.")
	} else {
		fmt.println("failed to acquire lock.")
	}
}

// acquirelock 尝试获取锁
func acquirelock(ctx context.context, client *redis.client, key string, timeout time.duration) bool {
	// 设置键值对，只有当键不存在时才设置，并设置过期时间
	result, err := client.setnx(ctx, key, "locked", timeout).result()
	if err != nil {
		log.fatalf("failed to acquire lock: %v", err)
	}
	return result
}

// releaselock 释放锁
func releaselock(ctx context.context, client *redis.client, key string) {
	// 删除键
	err := client.del(ctx, key).err()
	if err != nil {
		log.printf("failed to release lock: %v", err)
	}
}

注意事项

超时时间：设置合理的超时时间，防止死锁。如果持有锁的进程崩溃，锁不会永远占用。
幂等性：确保释放锁的操作是幂等的，即多次调用 releaselock 不会出问题。
竞争条件：在高并发场景下，可能会出现竞争条件。可以通过 lua 脚本来确保原子性操作。
安全性：确保只有持有锁的进程才能释放锁。可以通过在 set 命令中设置唯一的值来实现这一点。

使用 lua 脚本确保原子性

为了确保释放锁的操作是原子的，可以使用 lua 脚本来实现。以下是一个改进的示例：

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/go-redis/redis/v8"
)

var ctx = context.background()

func main() {
	// 初始化 redis 客户端
	rdb := redis.newclient(&redis.options{
		addr:     "localhost:6379", // redis 地址
		password: "",               // 密码
		db:       0,                // 数据库编号
	})

	// 锁的键名和超时时间
	key := "my_lock"
	value := "unique_value"
	timeout := time.second * 10

	// 尝试获取锁
	lockacquired := acquirelock(ctx, rdb, key, value, timeout)
	if lockacquired {
		defer releaselock(ctx, rdb, key, value)

		// 在这里执行需要加锁的操作
		fmt.println("lock acquired, performing critical section operations...")
		time.sleep(time.second * 5) // 模拟耗时操作
		fmt.println("critical section operations completed.")
	} else {
		fmt.println("failed to acquire lock.")
	}
}

// acquirelock 尝试获取锁
func acquirelock(ctx context.context, client *redis.client, key, value string, timeout time.duration) bool {
	// 设置键值对，只有当键不存在时才设置，并设置过期时间
	result, err := client.setnx(ctx, key, value, timeout).result()
	if err != nil {
		log.fatalf("failed to acquire lock: %v", err)
	}
	return result
}

// releaselock 释放锁
func releaselock(ctx context.context, client *redis.client, key, value string) {
	// 使用 lua 脚本确保释放锁的操作是原子的
	script := redis.newscript(`
		if redis.call("get", keys[1]) == argv[1] then
			return redis.call("del", keys[1])
		else
			return 0
		end
	`)
	err := script.run(ctx, client, []string{key}, value).err()
	if err != nil {
		log.printf("failed to release lock: %v", err)
	}
}

使用 set 命令和 lua 脚本可以确保操作的原子性和安全性。

====================

在分布式锁的实现中，key 是一个非常重要的参数，它用于唯一标识一个锁。下面详细解释 key 在 acquirelock 方法中的作用：

key 的作用

唯一标识锁：
- key 是一个字符串，用于唯一标识一个特定的锁。不同的锁应该有不同的 key，这样可以确保不同的资源可以独立地被锁定。
- 例如，如果你有两个资源 resource1 和 resource2，你可以分别为它们设置不同的 key，比如 "lock:resource1" 和 "lock:resource2"。
存储锁的状态：
- 当你尝试获取锁时，key 被用作 redis 中的一个键。如果这个键已经存在，说明已经有其他客户端持有了这个锁。
- 如果键不存在，redis 会设置这个键，并将其值设为你提供的值（例如 "locked" 或一个唯一的标识符）。
设置过期时间：
- 在设置键的同时，你可以为键设置一个过期时间（使用 ex 参数）。这可以防止锁由于客户端崩溃或其他原因而永远占用。
- 过期时间确保了即使持有锁的客户端出现问题，锁最终也会自动释放。

示例代码中的 key 使用

在之前的示例代码中，key 被用于 acquirelock 方法中：

func acquirelock(ctx context.context, client *redis.client, key, value string, timeout time.duration) bool {
    // 设置键值对，只有当键不存在时才设置，并设置过期时间
    result, err := client.setnx(ctx, key, value, timeout).result()
    if err != nil {
        log.fatalf("failed to acquire lock: %v", err)
    }
    return result
}

key：用于唯一标识锁的键。
value：设置键的值，可以是一个固定的字符串（如 "locked"），也可以是一个唯一的标识符（如客户端的唯一 id）。
timeout：设置键的过期时间，单位为秒。

具体示例

假设你有两个资源 resource1 和 resource2，你可以分别为它们设置不同的 key：

key1 := "lock:resource1"
key2 := "lock:resource2"

// 尝试获取 resource1 的锁
lockacquired1 := acquirelock(ctx, rdb, key1, "unique_value1", time.second * 10)
if lockacquired1 {
    defer releaselock(ctx, rdb, key1, "unique_value1")

    // 在这里执行需要加锁的操作
    fmt.println("lock acquired for resource1, performing critical section operations...")
    time.sleep(time.second * 5) // 模拟耗时操作
    fmt.println("critical section operations completed for resource1.")
} else {
    fmt.println("failed to acquire lock for resource1.")
}

// 尝试获取 resource2 的锁
lockacquired2 := acquirelock(ctx, rdb, key2, "unique_value2", time.second * 10)
if lockacquired2 {
    defer releaselock(ctx, rdb, key2, "unique_value2")

    // 在这里执行需要加锁的操作
    fmt.println("lock acquired for resource2, performing critical section operations...")
    time.sleep(time.second * 5) // 模拟耗时操作
    fmt.println("critical section operations completed for resource2.")
} else {
    fmt.println("failed to acquire lock for resource2.")
}