Redis锁场景和方案实现详解：从基础到分布式的全栈实践

前言

在分布式系统中，锁是实现资源互斥访问的关键技术。Redis凭借高性能和原子操作特性，成为实现分布式锁的主流方案。本文将深入解析Redis锁的核心原理、典型场景及实现方案，结合具体代码示例，帮助开发者构建安全、高效的分布式锁系统。

---

一、Redis锁的基础原理与核心特性

1. 原子操作实现锁的基础

Redis通过SETNX（SET if Not eXists）命令实现原子性锁操作：

# 设置锁（原子操作）
SET resource_name unique_value NX PX 30000

# 参数说明：
# NX - 仅当键不存在时设置
# PX 30000 - 设置过期时间30秒（毫秒）

2. 分布式锁的三大核心要素

要素	说明	实现方式
互斥性	同一时间只有一个客户端持有锁	通过SETNX原子操作保证
锁释放	锁必须被持有锁的客户端释放，防止死锁	使用唯一值校验+Lua脚本
容错性	即使Redis节点故障，锁机制仍能正常工作	RedLock算法（多节点）

---

二、基础分布式锁实现与问题

1. 基础实现（存在缺陷）

public class RedisLock {
   
    private Jedis jedis;
    private static final String LOCK_KEY = "resource_lock";
    
    public RedisLock(Jedis jedis) {
   
        this.jedis = jedis;
    }
    
    // 加锁（存在缺陷）
    public boolean lock(String requestId, int expireTime) {
   
        String result = jedis.set(LOCK_KEY, requestId, "NX", "PX", expireTime);
        return "OK".equals(result);
    }
    
    // 解锁（存在缺陷）
    public void unlock(String requestId) {
   
        if (requestId.equals(jedis.get(LOCK_KEY))) {
   
            jedis.del(LOCK_KEY);
        }
    }
}

2. 存在的问题分析

（1）原子性问题

• 问题场景：判断锁是否属于当前客户端和释放锁的操作不是原子的
• 可能结果：锁被其他客户端误释放

（2）锁过期问题

• 问题场景：业务执行时间超过锁过期时间
• 可能结果：锁提前释放，导致多个客户端同时持有锁

（3）单点故障

• 问题场景：主从复制架构中，主节点挂掉导致锁丢失
• 可能结果：多个客户端同时获取到锁

---

三、优化方案与最佳实践

1. 原子性解锁（Lua脚本）

// 使用Lua脚本保证原子性解锁
public void unlockWithLua(String requestId) {
   
    String script = 
        "if redis.call('get', KEYS[1]) == ARGV[1] then " +
        "   return redis.call('del', KEYS[1]) " +
        "else " +
        "   return 0 " +
        "end";
    
    jedis.eval(script, Collections.singletonList(LOCK_KEY), 
               Collections.singletonList(requestId));
}

2. 锁续期机制（看门狗）

// 基于Redisson的锁续期实现
public void redissonLockExample() {
   
    RLock lock = redissonClient.getLock("resource_lock");
    
    try {
   
        // 尝试获取锁，等待100秒，锁自动释放时间30秒
        boolean isLocked = lock.tryLock(100, 30, TimeUnit.SECONDS);
        
        if (isLocked) {
   
            // 执行业务逻辑
            processBusiness();
        }
    } catch (InterruptedException e) {
   
        Thread.currentThread().interrupt();
    } finally {
   
        // 释放锁
        if (lock.isHeldByCurrentThread())