分布式锁实战：Redis与Redisson的深度解析

一、分布式锁的必要性

在分布式系统中，当多个节点需要对共享资源进行读写操作时，传统的本地锁（如Java的synchronized或ReentrantLock）无法跨节点生效。此时，必须引入分布式锁来保证操作的原子性和一致性。分布式锁需满足以下核心特性：

1. 互斥性：任意时刻仅一个客户端持有锁
2. 防死锁：即使持有锁的客户端崩溃，锁仍可被释放
3. 可重入性：同一客户端可多次获取同一把锁
4. 一致性：解锁操作必须由锁的持有者执行

二、Redis分布式锁实现

Redis实现分布式锁主要利用Redis的setnx命令。
SETNX key value 是 Redis 的原子性命令，用于设置键值对，仅当键不存在时生效，否则不执行任何操作。

1. 基础实现（SETNX+EXPIRE）

// 加锁（非原子操作）
if (redisTemplate.execute((RedisCallback<Long>) connection -> connection.setNX(lockKey.getBytes(), UUID.randomUUID().toString().getBytes())) == 1) {
    redisTemplate.expire(lockKey, expireTime, TimeUnit.SECONDS);
    return true;
}
return false;

• 问题：SETNX与EXPIRE的非原子性导致可能存在锁未设置过期时间的风险

2. 原子化实现（SET命令增强）

// 原子化加锁
Boolean success = redisTemplate.execute((RedisCallback<Boolean>) connection -> 
    connection.set(lockKey.getBytes(), UUID.randomUUID().toString().getBytes(), 
        Expiration.seconds(expireTime), RedisStringCommands.SetOption.SET_IF_ABSENT));
return success != null && success;

• 优势：通过SET命令的NX选项实现原子性加锁与过期时间设置

3. 解锁实现

// 解锁（需验证锁归属）
if (UUID.fromString(redisTemplate.opsForValue().get(lockKey)).equals(currentUuid)) {
    redisTemplate.delete(lockKey);
}

三、Redis锁的缺陷与优化

1. 锁过期问题

• 现象：业务执行时间超过锁过期时间，导致锁提前释放
• 解决方案：
  • 动态调整过期时间
  • 使用Redisson的看门狗机制

2. 锁误删风险

• 现象：客户端A的锁过期后，客户端B获取锁并被客户端A误删
• 解决方案：

  // 使用Lua脚本保证原子性
  String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
  redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(lockKey), currentUuid);
  

四、Redisson分布式锁进阶

1. 加锁过程

当一个线程尝试获取分布式锁时，Redisson 会执行以下操作：

• 原子操作：使用 Redis 的 SETNX（SET if Not eXists）命令来尝试设置一个键值对，键表示锁的名称，值表示持有锁的线程标识（通常是一个 UUID）。如果设置成功，说明该线程成功获取到锁；如果设置失败，说明锁已经被其他线程持有。
• 设置过期时间：为了避免锁被永久持有（例如持有锁的线程崩溃），Redisson 会为锁设置一个过期时间。可以使用 SET 命令的 NX 和 EX 选项来原子性地完成设置键值对和过期时间的操作。
• 锁重入：Redisson 支持锁重入，即同一个线程可以多次获取同一把锁而不会死锁。为了实现锁重入，Redisson 在 Redis 中存储的键值对的值是一个计数器，每次线程获取锁时计数器加 1，释放锁时计数器减 1，当计数器为 0 时才真正释放锁。

2. 锁续期机制

为了防止在业务逻辑执行期间锁过期，Redisson 引入了锁续期机制，也称为“看门狗”机制：

• 定时任务：当线程成功获取锁后，Redisson 会启动一个定时任务，该任务会在锁过期时间的三分之一处执行，尝试对锁进行续期。
• Lua 脚本：续期操作使用 Lua 脚本来保证原子性，脚本会检查锁的持有者是否还是当前线程，如果是则更新锁的过期时间。

3. 释放锁过程

当线程完成业务逻辑后，需要释放锁，Redisson 会执行以下操作：

• 计数器减 1：如果是锁重入的情况，先将计数器减 1。
• 释放锁：当计数器为 0 时，使用 Lua 脚本来删除 Redis 中的键值对，从而释放锁。Lua 脚本可以保证删除操作的原子性，避免在删除过程中出现并发问题。

示例代码

以下是一个简单的 Java 代码示例，展示了如何使用 Redisson 获取和释放分布式锁：

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

import java.util.concurrent.TimeUnit;

public class RedissonLockExample {
    public static void main(String[] args) {
        // 创建 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 {
            // 尝试获取锁，等待 10 秒，锁的过期时间为 30 秒
            boolean isLocked = lock.tryLock(10, 30, TimeUnit.SECONDS);
            if (isLocked) {
                // 模拟业务逻辑
                System.out.println("获取到锁，开始执行业务逻辑");
                Thread.sleep(5000);
                System.out.println("业务逻辑执行完毕");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放锁
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
                System.out.println("锁已释放");
            }
        }

        // 关闭 Redisson 客户端
        redisson.shutdown();
    }
}

4. 锁模式对比

锁类型	特性	适用场景
公平锁	按等待顺序分配锁	高并发有序场景
联锁	多个独立Redis节点的组合锁	金融级安全场景
红锁	多数节点达成共识的锁机制	分布式系统强一致性要求

五、最佳实践建议

1. 锁粒度控制：避免粗粒度锁，优先使用细粒度锁
2. 过期时间设置：根据业务耗时合理设置，建议30-60秒
3. 异常处理：所有加锁操作必须包含finally块释放锁
4. 监控报警：对锁竞争、锁超时等异常情况进行监控
5. 降级策略：锁获取失败时要有回退机制，避免系统雪崩

六、总结

Redis原生锁与Redisson框架为分布式锁提供了不同层级的解决方案：

• Redis原生方案适用于轻量级场景，需关注原子性与锁过期问题
• Redisson框架通过自动续期、多种锁模式等特性，提供了企业级的分布式锁解决方案

在实际应用中，应根据系统规模、一致性要求和业务特性选择合适的实现方式，同时结合监控和报警机制保障系统的稳定性。