通过lua实现redis 分布式锁的项目实践

-- KEYS[1] = 锁的 key（如 "my_lock"）
-- ARGV[1] = 锁的 value（唯一标识，如 UUID）
-- ARGV[2] = 过期时间（毫秒，如 "30000"）

local key = KEYS[1]
local value = ARGV[1]
local ttl = tonumber(ARGV[2])

-- 尝试加锁：只有当 key 不存在时才设置成功
if redis.call("SET", key, value, "NX", "PX", ttl) then
    return 1  -- 加锁成功
else
    return 0  -- 加锁失败（已被占用）
end

-- KEYS[1] = 锁的 key
-- ARGV[1] = 锁的 value（用于验证是否是自己的锁）

local key = KEYS[1]
local value = ARGV[1]

-- 获取当前锁的 value
local current_value = redis.call("GET", key)

-- 如果存在且等于自己的 value，则删除
if current值 == value then
    redis.call("DEL", key)
    return 1  -- 解锁成功
else
    return 0  -- 不是自己的锁，拒绝删除
end

import redis
import uuid
import time

# 初始化 Redis 连接
r = redis.StrictRedis(host='localhost', port=6379, decode_responses=True)

# 加载 Lua 脚本（推荐使用 script_load + evalsha 提高性能）
lock_script = r.register_script("""
if redis.call("SET", KEYS[1], ARGV[1], "NX", "PX", ARGV[2]) then
    return 1
else
    return 0
end
""")

unlock_script = r.register_script("""
if redis.call("GET", KEYS[1]) == ARGV[1] then
    return redis.call("DEL", KEYS[1])
else
    return 0
end
""")

def acquire_lock(lock_name, acquire_timeout=10, lock_timeout=30):
    """获取分布式锁"""
    identifier = str(uuid.uuid4())
    lock_timeout_ms = int(lock_timeout * 1000)
    end_time = time.time() + acquire_timeout

    while time.time() < end_time:
        # 执行 Lua 脚本尝试加锁
        if lock_script(keys=[lock_name], args=[identifier, lock_timeout_ms]):
            return identifier  # 返回锁标识
        time.sleep(0.01)  # 短暂等待后重试

    return False

def release_lock(lock_name, identifier):
    """释放分布式锁"""
    unlock_script(keys=[lock_name], args=[identifier])

# ===== 使用示例 =====
lock_key = "order:123:lock"

# 尝试获取锁
lock_id = acquire_lock(lock_key, acquire_timeout=5, lock_timeout=30)
if lock_id:
    try:
        print("✅ 获取锁成功，执行业务逻辑...")
        time.sleep(5)  # 模拟业务处理
    finally:
        # 释放锁
        release_lock(lock_key, lock_id)
        print("🔓 锁已释放")
else:
    print("❌ 获取锁超时")

-- KEYS[1] = 锁 key
-- ARGV[1] = 客户端 ID
-- ARGV[2] = 锁过期时间（毫秒）

local key = KEYS[1]
local client_id = ARGV[1]
local ttl = tonumber(ARGV[2])

-- 检查是否已持有锁
local current_client = redis.call("HGET", key, client_id)

if current_client then
    -- 已持有：重入次数 +1，刷新 TTL
    redis.call("HINCRBY", key, client_id, 1)
    redis.call("PEXPIRE", key, ttl)
    return 1
else
    -- 未持有：尝试获取锁
    if redis.call("HLEN", key) == 0 then
        -- 锁空闲，创建
        redis.call("HMSET", key, client_id, 1)
        redis.call("PEXPIRE", key, ttl)
        return 1
    else
        -- 锁被他人持有
        return 0
    end
end

-- KEYS[1] = 锁 key
-- ARGV[1] = 客户端 ID

local key = KEYS[1]
local client_id = ARGV[1]

-- 检查是否持有锁
local counter = redis.call("HGET", key, client_id)

if not counter then
    return 0  -- 未持有锁
end

counter = tonumber(counter)

if counter > 1 then
    -- 重入次数 >1，减1
    redis.call("HINCRBY", key, client_id, -1)
    return 1
else
    -- 最后一次，删除整个 key
    redis.call("DEL", key)
    return 1
end