Go 使用 Redis 实现分布式锁
Go 使用 Redis 实现分布式锁
Redis 提供了一些原语，可以帮助我们实现高效的分布式锁。下边是使用 Redis 实现分布式锁的一种常见方法
实现分布式锁的方法
1. 使用 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.")
}
KEY
key 在分布式锁的实现中起到了唯一标识锁的作用。通过为不同的资源设置不同的 key，可以确保不同的资源可以独立地被锁定。同时，key 还用于存储锁的状态，并可以设置过期时间以防止死锁。