Redis 实现分布式锁+执行lua脚本

'# Redis 实现分布式锁+执行Lua脚本

一、背景与问题

在分布式系统中，多个服务实例可能同时访问共享资源，如数据库、缓存、文件系统等。这种场景下，如何保证数据一致性成为核心问题。传统的互斥锁（如Java的synchronized）无法解决分布式环境下的并发控制问题，而Redis提供的分布式锁机制，结合Lua脚本的原子性操作，成为解决这一问题的可靠方案。

核心挑战在于：

如何确保锁的获取和释放操作的原子性
如何避免锁的死锁和资源竞争
如何在高并发场景下保证系统的可用性

二、基本原理

1. Redis分布式锁的实现原理

Redis通过SET命令的NX和EX选项实现分布式锁：

NX（Not eXists）：键不存在时设置成功，存在时返回失败
EX（Expire）：设置键的过期时间（秒）

完整的锁获取逻辑包含：

# 获取锁
SET lock_key "value" NX PX 30000

当多个客户端同时执行上述命令时，只有第一个客户端能成功设置键，其余客户端将返回nil。这通过Redis的单线程特性保证了原子性。

2. Lua脚本的原子性保证

Redis将Lua脚本视为原子操作，即使脚本中包含多个命令。这种特性使得我们可以在一个脚本中完成复杂的锁控制逻辑，避免因网络延迟导致的竞态条件。

三、环境准备

1. Redis服务部署

确保已安装并运行Redis服务：

# 安装Redis（以Linux系统为例）
sudo apt-get install redis-server

# 验证服务状态
redis-server --version

2. 开发环境配置

使用Python3作为开发语言，安装依赖：

pip install redis

四、核心实现

1. 基础锁操作（Python示例）

import redis
import time
import uuid

def get_lock(r, lock_key, expire=30):
    """获取分布式锁"""
    # 生成唯一标识符
    identifier = uuid.uuid4().hex
    # 使用Lua脚本确保原子性
    script = """
    if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then
        return redis.call('expire', KEYS[1], ARGV[2])
    else
        return 0
    end
    """
    # 执行Lua脚本
    return r.eval(script, 1, lock_key, identifier, expire)

def release_lock(r, lock_key, identifier):
    """释放分布式锁"""
    script = """
    if redis.call('get', KEYS[1]) == ARGV[1] then
        return redis.call('del', KEYS[1])
    else
        return 0
    end
    """
    return r.eval(script, 1, lock_key, identifier)

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

# 获取锁
if get_lock(r, lock_key):
    try:
        # 执行业务逻辑
        print("获得锁，执行业务操作...")
        time.sleep(5)
    finally:
        # 释放锁
        release_lock(r, lock_key, identifier)
else:
    print("未能获得锁")

关键代码解释：

uuid.uuid4().hex：生成唯一标识符，用于区分不同客户端
eval方法执行Lua脚本，确保原子性
setnx和expire的组合保证锁的自动释放（防止死锁）

2. 带超时机制的锁（Lua脚本优化）

-- 优化后的Lua脚本
local key = KEYS[1]
local value = ARGV[1]
local expire = tonumber(ARGV[2])

if redis.call('setnx', key, value) == 1 then
    redis.call('expire', key, expire)
    return 1
else
    return 0
end

3. 多锁场景的处理

def acquire_multiple_locks(r, lock_keys, expire=30):
    """获取多个锁"""
    script = """
    local success = 0
    local keys = {}
    for i, key in ipairs(KEYS) do
        if redis.call('setnx', key, ARGV[1]) == 1 then
            success = success + 1
            redis.call('expire', key, tonumber(ARGV[2]))
        end
    end
    return success
    """
    identifiers = [uuid.uuid4().hex for _ in lock_keys]
    return r.eval(script, len(lock_keys), *lock_keys, *identifiers, expire)

五、完整案例

1. 分布式计数器系统

import threading
import time

class DistributedCounter:
    def __init__(self, r, lock_key):
        self.r = r
        self.lock_key = lock_key
        self.identifier = f"counter_{uuid.uuid4().hex}"
    
    def increment(self):
        """原子性递增操作"""
        script = """
        local current = tonumber(redis.call('get', KEYS[1]) or 0)
        local new = current + 1
        redis.call('set', KEYS[1], new)
        redis.call('expire', KEYS[1], 60)
        return new
        """
        return self.r.eval(script, 1, self.lock_key)
    
    def __enter__(self):
        """获取锁"""
        if get_lock(self.r, self.lock_key):
            return self
        raise Exception("Failed to acquire lock")
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        """释放锁"""
        release_lock(self.r, self.lock_key, self.identifier)

# 使用示例
counter = DistributedCounter(redis.Redis(), "counter_lock")
with counter:
    print("计数器值:", counter.increment())
    print("计数器值:", counter.increment())

运行结果：

计数器值: 1
计数器值: 2

六、源码解析

1. Redis源码中的锁机制

在Redis源码中，SET命令的实现位于set.c文件，关键逻辑如下：

// set.c 中的SET命令处理
void setCommand(redisClient *c) {
    // 处理NX选项
    if (c->argv[2] && strcmp(c->argv[2], "nx") == 0) {
        if (redisIsKeyExpired(c->argv[1], c->db) == 0) {
            // 设置成功
        } else {
            // 设置失败
        }
    }
    // 处理EX选项
    if (c->argv[3] && strcmp(c->argv[3], "ex") == 0) {
        // 设置过期时间
    }
}

2. Lua脚本执行机制

Redis通过eval命令执行Lua脚本，其核心逻辑在lua.c中：

// lua.c 中的Lua执行函数
void luaEvalCommand(redisClient *c) {
    // 创建Lua虚拟机
    lua_State *lua = luaL_newstate();
    // 加载Lua脚本
    luaL_loadbuffer(lua, script, len, "Lua script");
    // 执行脚本
    lua_pcall(lua, 1, 0, 0);
    // 处理返回结果
}

七、进阶使用

1. 红锁算法实现

Redis官方推荐的红锁算法（Redlock）适用于高可用场景，其核心逻辑如下：

客户端获取当前时间
依次在N个Redis实例上获取锁（每个实例设置过期时间）
如果在多数实例上获取锁成功，则认为锁获取成功
计算锁获取的总时间，若超过设定阈值则失败

2. 带重试机制的锁获取

def get_lock_with_retry(r, lock_key, expire=30, max_retry=3):
    for i in range(max_retry):
        if get_lock(r, lock_key, expire):
            return True
        time.sleep(0.1 * (i+1))
    return False

八、性能与工程实践

1. 性能优化策略

优化措施	说明
设置合理过期时间	避免锁长期占用
使用Lua脚本减少网络请求	降低延迟
优化锁粒度	避免锁范围过大
使用Redis集群	提高可用性
采用缓存热数据	减少对锁的依赖

2. 异常处理机制

锁获取失败时应重试机制
锁释放时应检查标识符有效性
网络异常时应尝试重新获取锁
设置锁的超时时间避免死锁

3. 安全性考虑

禁用Redis的CONFIG命令，防止配置修改
设置密码认证（requirepass）
限制Redis的访问IP
对Lua脚本进行严格的输入校验
避免使用EVAL命令直接执行用户输入的脚本

九、常见问题与踩坑

1. 常见错误分析

错误场景	原因	解决方案
锁未释放	未正确设置标识符	确保释放锁时使用相同标识符
死锁	锁未设置过期时间	必须配合EX参数使用
竞态条件	多个客户端同时获取锁	使用Lua脚本确保原子性
脚本执行失败	Lua语法错误	使用`redis-cli --eval`测试脚本
资源争用	锁粒度太粗	细化锁的粒度，按业务划分

2. 常见错误示例

# 错误示例：未设置过期时间
get_lock(r, lock_key)  # 错误：未指定EX参数

改进方案：

get_lock(r, lock_key, expire=30)  # 正确：设置过期时间

十、最佳实践

1. 推荐方案

使用SET命令的NX和EX选项实现基本锁
在复杂逻辑中使用Lua脚本保证原子性
对关键业务逻辑进行锁保护
设置合理的锁过期时间（一般30秒-5分钟）
使用UUID作为标识符，避免重复
对锁的操作进行日志记录

2. 推荐的实现方式

场景	推荐方式
简单锁	SET NX EX
复杂逻辑	Lua脚本
多锁场景	多键同时处理
高可用	Redlock算法
长时间锁	配合异步处理

十一、总结

Redis分布式锁结合Lua脚本，为分布式系统提供了可靠的并发控制机制。其核心原理是通过Redis的原子性操作和Lua脚本的执行保证了锁操作的正确性。在实际应用中，需要根据业务场景选择合适的实现方式，注意锁的粒度、过期时间和异常处理。

需要注意的是，分布式锁并非万能解决方案，对于非关键路径的业务逻辑，可以考虑其他方式（如消息队列、缓存穿透保护等）。同时，要避免因锁机制引入新的问题，如死锁、资源争用等。

在工程实践中，建议结合监控系统对锁的使用情况进行统计，及时发现潜在问题。对于关键业务场景，可以采用多层防护机制，如在锁保护的基础上增加业务逻辑的重试机制，确保系统的高可用性和稳定性。