#Redis 分布式锁

# 场景：库存扣减
# 两台服务器同时处理订单，都需要扣减库存
# 如果不加锁：

# Server1: GET stock = 100
# Server2: GET stock = 100
# Server1: stock = stock - 1 = 99
# Server2: stock = stock - 1 = 99  # 错误！应该是 98

# ❌ 错误实现：setnx 和 expire 分开
acquired = redis.setnx(lock_key, lock_value)
if acquired:
    redis.expire(lock_key, 10)  # 如果这行失败了呢？
    # Redis 挂了、重启、或者命令执行失败
    # lock_key 永不过期，其他客户端永远获取不到锁

# ✅ 正确实现：一条命令原子设置
acquired = redis.set(lock_key, lock_value, nx=True, ex=10)
# set nx ex 保证了：
# 1. setnx 的原子性（只有不存在时才设置）
# 2. 过期时间的原子设置（不会锁永不过期）

# ❌ 错误释放：直接删除
redis.delete(lock_key)
# 问题：
# T1: 客户端 A 获取锁，业务执行超时
# T2: 锁自动过期，客户端 B 获取锁
# T3: 客户端 A 业务执行完毕，删除锁
# T4: 删除的是客户端 B 的锁！

# Python 调用
def release_lock(lock_key, lock_value):
    lua = """
    if redis.call('get', KEYS[1]) == ARGV[1] then
        return redis.call('del', KEYS[1])
    else
        return 0
    end
    """
    redis.eval(lua, 1, lock_key, lock_value)

# 问题：
# 锁设置了 10 秒过期
# 但业务执行需要 30 秒
# T1: 获取锁
# T11: 锁过期（其他客户端可以获取锁）
# T1~T30: 业务仍在执行（但锁已经没了！）

# Redisson 框架的 watchdog 实现：
# 1. 锁默认过期时间 30 秒
# 2. 后台线程每 10 秒检查：如果仍持有锁，续期 30 秒
# 3. 业务执行完毕，手动释放锁后停止续期

# 伪代码：
def acquire_lock_with_watchdog(lock_key):
    lock_value = uuid.uuid4()
    redis.set(lock_key, lock_value, nx=True, ex=30)

    if acquired:
        # 启动 watchdog 线程
        watchdog_thread = start_daemon_thread(
            interval=10,
            func=lambda: redis.expire(lock_key, 30)  # 续期
        )
        return (lock_value, watchdog_thread)
    return None

import uuid
import time

class RedisLock:
    def __init__(self, redis_client, lock_key, timeout=10):
        self.redis = redis_client
        self.lock_key = lock_key
        self.timeout = timeout
        self.lock_value = str(uuid.uuid4())

    def acquire(self):
        # 原子设置：nx + ex
        return self.redis.set(
            self.lock_key,
            self.lock_value,
            nx=True,
            ex=self.timeout
        )

    def release(self):
        # Lua 脚本安全释放
        lua = """
        if redis.call('get', KEYS[1]) == ARGV[1] then
            return redis.call('del', KEYS[1])
        else
            return 0
        end
        """
        self.redis.eval(lua, 1, self.lock_key, self.lock_value)

    def __enter__(self):
        if not self.acquire():
            raise RuntimeError('Failed to acquire lock')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.release()
        return False

# 使用
with RedisLock(redis, 'order:lock:10086') as lock:
    # 业务逻辑
    order = decrement_stock(10086)