分布式锁实现方案详解 ⭐⭐⭐

public class SimpleRedisLock {

    private RedisTemplate<String, String> redisTemplate;

    public boolean tryLock(String key, String value, long expireTime) {
        // SETNX + 过期时间
        return Boolean.TRUE.equals(
            redisTemplate.opsForValue()
                .setIfAbsent(key, value, Duration.ofSeconds(expireTime))
        );
    }

    public void unlock(String key, String value) {
        // 释放锁：判断是自己的锁才能释放
        String currentValue = redisTemplate.opsForValue().get(key);
        if (value.equals(currentValue)) {
            redisTemplate.delete(key);
        }
    }
}

@Service
public class OrderService {

    @Autowired
    private RedissonClient redissonClient;

    public void createOrder(OrderRequest request) {
        // 获取锁（默认 30 秒锁自动释放，看门狗每 10 秒续期一次）
        RLock lock = redissonClient.getLock("order:lock:" + request.getUserId());

        try {
            // 尝试加锁，最多等待 5 秒，锁定后 30 秒自动释放
            boolean locked = lock.tryLock(5, 30, TimeUnit.SECONDS);
            if (!locked) {
                throw new BizException("系统繁忙，请稍后重试");
            }

            // 业务逻辑
            doCreateOrder(request);

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new BizException("系统异常");
        } finally {
            // 必须在 finally 中释放锁
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

// 使用看门狗（推荐）：锁自动续期，业务完成后再释放
RLock lock = redissonClient.getLock("resource:key");
lock.lock(); // 不传参数，看门狗自动续期

// 不使用看门狗：显式指定过期时间，业务执行完立刻释放
RLock lock = redissonClient.getLock("resource:key");
lock.lock(10, TimeUnit.SECONDS); // 10秒后自动释放，不续期

// 可重入计数器记录在 hash 结构中
// KEYS[1] = 锁名称
// HASH_KEY = 线程 ID
// HASH_VALUE = 重入次数

// 加锁时
if (exists(lockKey)) {
    // 锁已存在，检查是否是同一线程
    if (threadId == hexists(lockKey, threadId)) {
        hincrby(lockKey, threadId, 1); // 重入次数 +1
        expire(lockKey, 30s);          // 续期
        return true;
    }
} else {
    // 首次加锁
    hset(lockKey, threadId, 1);
    expire(lockKey, 30s);
    return true;
}

// Java 使用示例
public void outer() {
    RLock lock = redissonClient.getLock("shared-resource");
    lock.lock();
    try {
        // 外层逻辑
        inner(); // 递归调用同一把锁
    } finally {
        lock.unlock();
    }
}

public void inner() {
    RLock lock = redissonClient.getLock("shared-resource");
    lock.lock(); // 可重入，同线程直接通过
    try {
        // 内层逻辑
    } finally {
        lock.unlock();
    }
}

// 普通锁：不保证先到先得，高并发下可能产生饥饿
RLock lock = redissonClient.getLock("resource");

// 公平锁：按请求顺序排队，先到先得
RLock fairLock = redissonClient.getFairLock("resource");

fairLock.lock(10, TimeUnit.SECONDS);
// 内部实现：用 Redis 的有序集合（ZSET）记录请求顺序

// 3 个独立 Redis 实例
RedissonClient redisson1 = Redisson.create(config1);
RedissonClient redisson2 = Redisson.create(config2);
RedissonClient redisson3 = Redisson.create(config3);

RedissonRedLock redLock = new RedissonRedLock(
    redisson1.getLock("resource"),
    redisson2.getLock("resource"),
    redisson3.getLock("resource")
);

try {
    // 尝试获取锁，最多等待 10s，锁定后 30s 自动释放
    redLock.tryLock(10, 30, TimeUnit.SECONDS);

    // 业务逻辑

} finally {
    redLock.unlock();
}

public boolean tryLock(String lockKey, String lockValue, int expireSeconds) {
    try {
        Lock record = new Lock();
        record.setLockKey(lockKey);
        record.setLockValue(lockValue);
        record.setExpireAt(LocalDateTime.now().plusSeconds(expireSeconds));
        lockMapper.insert(record);
        return true; // 成功（之前没有记录）
    } catch (DuplicateKeyException e) {
        return false; // 锁已被占用
    }
}

public void unlock(String lockKey, String lockValue) {
    // 只删除自己的锁
    lockMapper.deleteByKeyAndValue(lockKey, lockValue);
}