Redis分布式锁实现详解

分布式锁概述

分布式锁是在分布式环境下，控制多个进程或线程对共享资源进行访问的一种机制。Redis作为一种高性能的内存数据库，常被用来实现分布式锁，主要解决分布式系统中的并发控制问题。

Redis分布式锁的核心实现方式

1. SETNX + EXPIRE（基础实现）

这是最基础的实现方式，利用Redis的SETNX（SET if Not eXists）命令和EXPIRE命令。

// 获取锁
public boolean tryLock(String key, String value, long expireTime) {
    // SETNX命令，当key不存在时设置成功返回1，存在时返回0
    Long result = jedis.setnx(key, value);
    if (result == 1) {
        // 设置过期时间，防止死锁
        jedis.expire(key, expireTime);
        return true;
    }
    return false;
}

// 释放锁
public boolean unlock(String key, String value) {
    // 检查是否是锁的持有者
    String currentValue = jedis.get(key);
    if (value.equals(currentValue)) {
        // 删除锁
        jedis.del(key);
        return true;
    }
    return false;
}

缺点：SETNX和EXPIRE是两个操作，如果在SETNX之后，EXPIRE之前服务器宕机，锁将不会设置过期时间，导致死锁。

2. SET命令扩展 + Lua脚本（改进实现）

为了解决原子性问题，使用Redis的SET命令的扩展选项，将SETNX和EXPIRE合并为一个原子操作。

// 获取锁
public boolean tryLock(String key, String value, long expireTime) {
    // 使用SET命令的NX和EX选项，原子性地完成设置和过期时间
    String result = jedis.set(key, value, "NX", "EX", expireTime);
    return "OK".equals(result);
}

// 释放锁（使用Lua脚本保证原子性）
public boolean unlock(String key, String value) {
    String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    Long result = (Long) jedis.eval(luaScript, Collections.singletonList(key), Collections.singletonList(value));
    return result == 1;
}

优点：保证了获取锁和设置过期时间的原子性，Lua脚本确保释放锁的原子性。

缺点：仍然存在锁续期问题，如果业务操作时间超过锁的过期时间，锁会自动释放，导致并发问题。

3. RedLock算法（Redis官方推荐算法）

RedLock算法通过在多个独立的Redis实例上获取锁，提高分布式锁的可靠性和安全性。

public boolean tryLock(String key, String value, long expireTime) {
    // 假设有5个独立的Redis实例
    List<Jedis> jedisList = getJedisList();
    int successCount = 0;
    
    // 在每个Redis实例上尝试获取锁
    for (Jedis jedis : jedisList) {
        String result = jedis.set(key, value, "NX", "EX", expireTime);
        if ("OK".equals(result)) {
            successCount++;
        }
    }
    
    // 如果在大多数实例上获取锁成功，则认为获取锁成功
    if (successCount >= jedisList.size() / 2 + 1) {
        return true;
    }
    
    // 如果获取锁失败，则释放已经获取的锁
    for (Jedis jedis : jedisList) {
        String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        jedis.eval(luaScript, Collections.singletonList(key), Collections.singletonList(value));
    }
    
    return false;
}

优点：提高了分布式锁的可靠性，防止单点故障。

缺点：实现复杂，对时钟依赖较强。

4. Redisson（Java客户端库实现）

Redisson是一个基于Redis的Java客户端库，提供了完整的分布式锁解决方案。

// 创建Redisson客户端
Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379");
RedissonClient redisson = Redisson.create(config);

// 获取锁对象
RLock lock = redisson.getLock("myLock");

try {
    // 尝试获取锁，最多等待100秒，锁自动过期时间为30秒
    boolean locked = lock.tryLock(100, 30, TimeUnit.SECONDS);
    if (locked) {
        // 执行业务逻辑
        doBusiness();
    }
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    // 释放锁
    if (lock.isHeldByCurrentThread()) {
        lock.unlock();
    }
}

特点：

1. 使用Lua脚本保证操作的原子性
2. 实现了锁的自动续期（看门狗机制）
3. 支持可重入锁
4. 支持等待获取锁
5. 支持锁的过期时间设置

Redis分布式锁的优缺点

优点

• 性能高：Redis是基于内存的数据库，操作速度快
• 实现简单：基本的Redis分布式锁实现相对简单
• 可靠性较高：特别是使用RedLock算法或Redisson实现时

缺点

• 时钟依赖：RedLock算法对系统时钟有依赖，如果时钟发生漂移，可能导致问题
• 主从切换问题：在Redis主从架构下，如果主节点获取锁后立即宕机，且锁还未同步到从节点，可能导致多个客户端同时持有锁
• 实现复杂：高可靠性的分布式锁实现较为复杂，如RedLock算法

实际应用场景

1. 秒杀系统：控制商品库存的扣减，防止超卖
2. 定时任务：在分布式环境下，确保同一时间只有一个节点执行定时任务
3. 分布式事务：在分布式事务的执行过程中，确保事务的原子性和一致性
4. 资源访问控制：控制对共享资源的访问，如数据库连接、文件等

Redis分布式锁的最佳实践

1. 使用SET命令的NX和EX选项：确保设置锁和过期时间的原子性
2. 使用Lua脚本释放锁：确保检查锁和释放锁的原子性
3. 设置合理的过期时间：根据业务操作的平均耗时设置锁的过期时间
4. 实现锁续期机制：对于耗时较长的业务操作，实现锁的自动续期
5. 考虑使用成熟的客户端库：如Redisson，避免重复造轮子
6. 监控锁的使用情况：及时发现和解决锁相关的问题

总结

Redis分布式锁是分布式系统中控制共享资源访问的重要机制。从基础的SETNX+EXPIRE实现，到使用Lua脚本保证原子性，再到RedLock算法提高可靠性，以及Redisson提供的完整解决方案，每种实现方式都有其适用场景。在实际应用中，应根据业务需求和系统环境选择合适的实现方式，并遵循最佳实践以确保锁的可靠性和性能。