MyRedis分布式加锁解锁

一、背景与问题

在分布式系统中，多个服务实例可能同时操作共享资源（如库存、订单状态等），导致数据一致性问题。传统单机锁（如Java的synchronized）无法满足分布式场景需求。Redis通过原子操作提供了分布式锁的实现方案，但其设计和使用存在诸多细节需要深入理解。

二、基本原理

Redis分布式锁的核心原理基于SETNX（Set if Not Exists）命令的原子性操作。其核心逻辑如下：

1. 使用SETNX key value尝试设置锁
2. 设置锁的过期时间（防止进程崩溃导致锁无法释放）
3. 通过Lua脚本保证锁的释放操作原子性

需要注意：单纯使用SETNX无法解决所有问题，需要结合过期时间、锁续期等机制。

三、环境准备

# 安装Redis
brew install redis

# 启动Redis服务
redis-server

四、核心实现

1. 基础实现（不推荐生产环境）

import redis
import time

def get_lock(redis_client, lock_key, expire=30):
    return redis_client.setnx(lock_key, 1)

def release_lock(redis_client, lock_key):
    redis_client.delete(lock_key)

# 使用示例
r = redis.Redis(host='localhost', port=6379, db=0)
lock_key = 'my_lock'

if get_lock(r, lock_key):
    try:
        print("获得锁")
        time.sleep(10)  # 模拟业务逻辑
    finally:
        release_lock(r, lock_key)
        print("释放锁")
else:
    print("获取锁失败")

关键问题：没有设置过期时间，可能导致锁无法释放（死锁）。

2. 带超时机制的实现

def get_lock_with_expire(redis_client, lock_key, expire=30):
    return redis_client.setnx(lock_key, 1)

def release_lock_with_expire(redis_client, lock_key):
    redis_client.expire(lock_key, 30)

# 使用示例
r = redis.Redis(host='localhost', port=6379, db=0)
lock_key = 'my_lock'

if get_lock_with_expire(r, lock_key):
    try:
        print("获得锁")
        time.sleep(10)
    finally:
        release_lock_with_expire(r, lock_key)
        print("释放锁")
else:
    print("获取锁失败")

关键改进：通过expire设置锁的过期时间，防止进程崩溃导致死锁。

3. 使用Lua脚本实现（推荐生产环境）

def get_lock_with_lua(redis_client, lock_key, expire=30, identifier=""):
    lua_script = """
        if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then
            return redis.call('expire', KEYS[1], ARGV[2])
        else
            return 0
        end
    """
    return redis_client.eval(lua_script, 1, lock_key, identifier, expire)

def release_lock_with_lua(redis_client, lock_key, identifier):
    lua_script = """
        if redis.call('get', KEYS[1]) == ARGV[1] then
            return redis.call('del', KEYS[1])
        else
            return 0
        end
    """
    return redis_client.eval(lua_script, 1, lock_key, identifier)

关键优势：

1. 使用Lua脚本保证原子性
2. 通过identifier区分不同业务场景
3. 支持锁的续期（需额外实现）

五、完整案例

1. 库存扣减场景

import redis
import time
import random

def deduct_stock(redis_client, product_id, stock):
    lock_key = f"stock_lock:{product_id}"
    identifier = str(random.random())
    
    if get_lock_with_lua(redis_client, lock_key, expire=10, identifier=identifier):
        try:
            print(f"开始扣减{product_id}库存")
            current_stock = int(redis_client.get(f"stock:{product_id}") or 0)
            
            if current_stock > 0:
                new_stock = current_stock - 1
                redis_client.set(f"stock:{product_id}", new_stock)
                print(f"库存更新为{new_stock}")
            else:
                print("库存不足")
        finally:
            release_lock_with_lua(redis_client, lock_key, identifier)
            print("释放锁")
    else:
        print("获取锁失败")

# 模拟高并发
r = redis.Redis(host='localhost', port=6379, db=0)
for i in range(10):
    deduct_stock(r, "product_1", 10)

关键点：

• 使用唯一标识符区分不同业务实例
• 设置合理的过期时间（10秒）
• 通过Lua脚本保证原子性

六、源码解析

1. Lua脚本执行流程

-- 获取锁的Lua脚本
if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then
    return redis.call('expire', KEYS[1], ARGV[2])
else
    return 0
end

关键点：

• setnx原子操作确保锁唯一性
• expire设置过期时间
• 返回值为1表示成功获取锁，0表示失败

2. 释放锁的Lua脚本

-- 释放锁的Lua脚本
if redis.call('get', KEYS[1]) == ARGV[1] then
    return redis.call('del', KEYS[1])
else
    return 0
end

关键点：

• 检查锁的值是否与当前标识符匹配
• 保证只有持有锁的实例才能释放锁
• 返回值为1表示成功释放，0表示失败

七、进阶使用

1. 锁续期机制

def renew_lock(redis_client, lock_key, identifier, expire=30):
    lua_script = """
        if redis.call('get', KEYS[1]) == ARGV[1] then
            return redis.call('expire', KEYS[1], ARGV[2])
        else
            return 0
        end
    """
    return redis_client.eval(lua_script, 1, lock_key, identifier, expire)

使用场景：在业务逻辑中定期续期锁（如每5秒续期一次）

2. 看门狗机制

import threading
import time

class LockDog:
    def __init__(self, redis_client, lock_key, identifier, expire=30):
        self.redis_client = redis_client
        self.lock_key = lock_key
        self.identifier = identifier
        self.expire = expire
        self.thread = threading.Thread(target=self.run)
    
    def run(self):
        while True:
            time.sleep(self.expire / 2)
            renew_lock(self.redis_client, self.lock_key, self.identifier, self.expire)
    
    def start(self):
        self.thread.start()

关键点：通过看门狗机制自动续期锁，避免锁过期导致的业务中断

八、性能与工程实践

1. 性能优化

2. 安全风险

九、常见问题与踩坑

1. 锁无法释放

# 错误示例：未设置过期时间
def bad_get_lock(redis_client, lock_key):
    return redis_client.setnx(lock_key, 1)

问题：进程崩溃后锁无法释放，导致死锁

改进方案：必须配合expire使用

2. 锁误删问题

# 错误示例：未校验标识符
def bad_release_lock(redis_client, lock_key):
    redis_client.delete(lock_key)

问题：其他实例可能误删锁

改进方案：使用Lua脚本校验标识符

3. 网络波动导致锁失效

# 错误示例：未处理网络异常
def bad_lock_operation(redis_client, lock_key):
    redis_client.setnx(lock_key, 1)

问题：网络波动可能导致锁失效

改进方案：使用SET命令的NX和EX选项

十、最佳实践

1. 使用Lua脚本：确保锁操作的原子性
2. 设置合理过期时间：建议10-30秒，根据业务场景调整
3. 唯一标识符：使用UUID或随机字符串区分不同业务实例
4. 看门狗机制：在业务逻辑中定期续期锁
5. 避免锁竞争：尽量减少锁的持有时间
6. 监控与告警：监控锁的获取和释放情况，设置异常告警

十一、总结

Redis分布式锁是解决分布式系统资源竞争的重要手段，但其设计和使用需要综合考虑多方面因素。本文深入解析了Redis分布式锁的原理、实现方式和使用场景，通过多个代码示例展示了不同实现方式的优劣。在实际开发中，应根据业务需求选择合适的实现方案，同时注意避免常见陷阱，如未设置过期时间、锁误删等问题。通过合理使用锁机制，可以有效保障分布式系统的数据一致性，同时避免潜在的安全风险。