深入浅出：具体场景下的redis分布式锁原理，实现与优化

昂子的博客

708人浏览 · 2025-11-17 23:04:32

昂子的博客 · 2025-11-17 23:04:32 发布

1. 分布式锁的基本原理和实现方式对比

分布式锁：满足分布式系统或集群模式下多进程可见并且互斥的锁。

分布式锁的核心思想就是让大家都使用同一把锁，只要大家使用的是同一把锁，那么我们就能锁住线程，不让线程进行，让程序串行执行，这就是分布式锁的核心思路。

那么分布式锁他应该满足一些什么样的条件呢？

可见性：多个线程都能看到相同的结果，注意：这个地方说的可见性并不是并发编程中指的内存可见性，只是说多个进程之间都能感知到变化的意思
互斥：互斥是分布式锁的最基本的条件，使得程序串行执行

高可用：程序不易崩溃，时时刻刻都保证较高的可用性
高性能：由于加锁本身就让性能降低，所有对于分布式锁本身需要他就较高的加锁性能和释放锁性能
安全性：安全也是程序中必不可少的一环

常见的分布式锁有三种

Mysql：mysql本身就带有锁机制，但是由于mysql性能本身一般，所以采用分布式锁的情况下，其实使用mysql作为分布式锁比较少见
Redis：redis作为分布式锁是非常常见的一种使用方式，现在企业级开发中基本都使用redis或者zookeeper作为分布式锁，利用setnx这个方法，如果插入key成功，则表示获得到了锁，如果有人插入成功，其他人插入失败则表示无法获得到锁，利用这套逻辑来实现分布式锁

Zookeeper：zookeeper也是企业级开发中较好的一个实现分布式锁的方案，但我们是redis教学，所以不过多阐述。

2. Redis分布式锁的实现核心思路

实现分布式锁时需要实现的两个基本方法：

获取锁：
- 互斥：确保只能有一个线程获取锁
- 非阻塞：尝试一次，成功返回true，失败返回false

释放锁：

手动释放
超时释放：获取锁时添加一个超时时间

核心思路：当一个线程尝试获取锁时，使用set [key] [value] NX EX [time]命令，判断结果，如果结果为nil ，说明在这之前已经有线程拿到锁了，获取锁失败。如果结果返回ok，则表明获取锁成功。万一锁没有正常释放，将来会超时自动释放。

3. 实现分布式锁版本一

下面我们就来实现一下初级版本的redis分布式锁。

1. 编写ILock接口

com.example.utils.ILock包下

public interface ILock {
    /**
     * 尝试获取锁
     * @param timeoutSec 锁持有的超时时间, 过期后自动释放
     * @return true代表锁获取成功, 否则获取失败
     */
    public boolean tryLock(Long timeoutSec);

    /**
     * 释放锁
     */
    public void unlock();
}

2. 编写初级版本分布式锁实现类

SimpleRedisLock 初级版本分布式锁
利用setnx方法进行加锁，同时增加过期时间，防止死锁，此方法可以保证加锁和增加过期时间具有原子性。

public class SimpleRedisLock implements ILock{

    private String keyName;

    private StringRedisTemplate stringRedisTemplate;

    private static final String KEY_PREFIX = "lock:";

    public SimpleRedisLock(String keyName, StringRedisTemplate stringRedisTemplate) {
        this.keyName = keyName;
        this.stringRedisTemplate = stringRedisTemplate;
    }
	/**
	 * 获取锁
	 *
	 **/
    @Override
    public boolean tryLock(Long timeoutSec) {
        //获取线程标识
        long threadId = Thread.currentThread().getId();
        //获取锁
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + keyName, threadId + "", timeoutSec, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(success);
    }
	/**
	 * 释放锁
	 *
	 **/
    @Override
    public void unlock() {
        stringRedisTemplate.delete(KEY_PREFIX + keyName);
    }
}

3. 修改`seckillVoucher`方法逻辑

将之前使用synchronized悲观锁实现的一人一单代码给注释掉，我们改用自己用redis实现的分布式锁。

4. Redis分布式锁误删情况说明

逻辑说明：

持有锁的线程1在锁的内部出现了阻塞(比如业务执行耗时太长)，导致他的锁自动释放(锁的超时时间小于业务执行耗时)，这时其他线程，线程2来尝试获得锁，就拿到了这把锁，然后线程2在持有锁执行过程中，线程1业务执行完了反应过来，走到了删除锁逻辑，此时就会把本应该属于线程2的锁进行删除，这就是误删别人锁的情况。

那么很明显导致这个问题的其中一个原因呢，是锁的超时时间太短导致的，另一个重要原因呢，就是一个线程误删了另一个线程的锁，导致了并发安全问题。

5. 解决Redis分布式锁误删问题

修改之前的分布式锁实现，满足在获取锁时存入自己的线程标示（可以用UUID表示）
在释放锁时先获取锁中的线程标示，判断是否与当前线程标示一致。

如果一致则释放锁
如果不一致则不释放锁

核心逻辑：在存入锁时，放入自己线程的标识，在删除锁时，判断当前这把锁的标识是不是自己存入的，如果是，则进行删除，如果不是，则不进行删除。

具体代码如下：
添加锁:

private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
@Override
public boolean tryLock(Long timeoutSec) {
    //获取线程标识
    String threadId = ID_PREFIX + Thread.currentThread().getId();
    //获取锁
    Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + keyName, threadId, timeoutSec, TimeUnit.SECONDS);
    return BooleanUtil.isTrue(success);
}

释放锁:

@Override
public void unlock() {
    //判断当前线程标识
    String threadId = ID_PREFIX + Thread.currentThread().getId();
    //获取锁中的标识
    String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + keyName);
    if(threadId.equals(id)){
        //释放锁
        stringRedisTemplate.delete(KEY_PREFIX + keyName);
    }
}

6. 分布式锁的原子性问题

更为极端的误删逻辑说明：

线程1现在持有锁之后，在执行业务逻辑过程中，他正准备删除锁，而且已经走到了条件判断的过程中，比如他已经拿到了当前这把锁确实是属于他自己的，正准备删除锁，但是此时我们的jvm进行Full GC(Java虚拟机中的一种垃圾回收机制)的时候，此时又会发生阻塞，而恰逢其时，触发了锁的超时释放，那么此时线程2进来执行业务，但是线程1他会接着往后执行，等待Full GC结束后，线程1直接就会执行删除锁那行代码，相当于条件判断并没有起到作用，这就是删锁时的原子性问题，之所以有这个问题，是因为线程1的判断锁标识以及释放锁，是两个不同时间的动作，也就是并不是原子性的，我们要防止刚才的情况发生。

如果你没有听懂，可以通过这几幅流程图来理解

原因就在于线程1已经获取了当前值之后，这个动作被打断了，不是原子性的，造成了后续的误删。

7. Lua脚本解决多条命令原子性问题

Redis提供了Lua脚本功能，在一个脚本中编写多条Redis命令，确保多条命令执行时的原子性。Lua是一种编程语言，它的基本语法大家可以参考网站：https://www.runoob.com/lua/lua-tutorial.html，这里重点介绍Redis提供的调用函数，我们可以使用lua去操作redis，又能保证他的原子性，这样就可以实现拿锁比锁删锁是一个原子性动作了，作为Java程序员这一块并不作一个简单要求，并不需要大家过于精通，只需要知道他有什么作用即可。

这里重点介绍Redis提供的调用函数，语法如下：

redis.call('命令名称', 'key', '其它参数', ...)

例如，我们要执行set name jack，则脚本是这样：

# 执行 set name jack
redis.call('set', 'name', 'jack')

例如，我们要先执行set name Rose，再执行get name，则脚本如下：

# 先执行 set name jack
redis.call('set', 'name', 'Rose')
# 再执行 get name
local name = redis.call('get', 'name')
# 返回
return name

写好脚本以后，需要用Redis命令来调用脚本，调用脚本的常见命令如下：

例如，我们要执行 redis.call('set', 'name', 'jack') 这个脚本，语法如下：

如果脚本中的key、value不想写死，可以作为参数传递。key类型参数会放入KEYS数组，其它参数会放入ARGV数组，在脚本中可以从KEYS和ARGV数组获取这些参数：

接下来我们来回一下我们释放锁的逻辑：

释放锁的业务流程是这样的

1、获取锁中的线程标示

2、判断是否与指定的标示（当前线程标示）一致

3、如果一致则释放锁（删除）

4、如果不一致则什么都不做

如果用Lua脚本来表示则是这样的：

最终我们操作redis的拿锁比锁删锁的lua脚本就会变成这样

-- 这里的 KEYS[1] 就是锁的key，这里的ARGV[1] 就是当前线程标示
-- 获取锁中的标示，判断是否与当前线程标示一致
if (redis.call('GET', KEYS[1]) == ARGV[1]) then
  -- 一致，则删除锁
  return redis.call('DEL', KEYS[1])
end
-- 不一致，则直接返回
return 0

8. 利用Java代码调用Lua脚本改造分布式锁

lua脚本本身并不需要大家花费太多时间去研究，只需要知道如何调用，大致是什么意思即可，所以在笔记中并不会详细的去解释这些lua表达式的含义。

我们的RedisTemplate中，可以利用execute方法去执行lua脚本，参数对应关系就如下图:

Java执行lua脚本代码：

/**
 * Redis分布式锁解锁实现类
 * 使用Lua脚本保证解锁操作的原子性，防止误删其他线程的锁
 */
@Component
public class RedisDistributedLock {
    
    /**
     * Redis脚本执行器实例，用于执行Lua脚本
     * Long：指定脚本返回值的类型（0-失败，1-成功）
     * static final：静态常量，确保在类加载时只初始化一次，避免重复创建
     */
    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;

    /**
     * 静态代码块：在类加载时执行，用于初始化UNLOCK_SCRIPT对象
     * 这个块只在类第一次加载时执行一次，提高性能
     */
    static {
        // 1. 创建DefaultRedisScript实例
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        
        // 2. 设置Lua脚本的位置：从classpath根目录加载unlock.lua文件
        //    脚本文件通常放在resources目录下
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
        
        // 3. 设置脚本返回值的类型为Long
        //    Lua脚本返回0表示解锁失败，1表示解锁成功
        UNLOCK_SCRIPT.setResultType(Long.class);
    }

    /**
     * 分布式锁解锁方法
     * 使用Lua脚本实现"比较锁标识+删除锁"的原子性操作
     * 解决传统先比较后删除的非原子操作可能导致的误删问题
     * 
     * @Override 表示重写父类或接口的方法，确保方法签名正确
     */
    @Override
    public void unlock() {
        /**
         * 执行Lua脚本完成原子性解锁操作：
         * 
         * 参数说明：
         * 1. UNLOCK_SCRIPT: 要执行的Lua脚本实例
         * 2. Collections.singletonList(KEY_PREFIX + keyName): 
         *    - 将锁的key包装成单元素列表，对应Lua脚本中的KEYS[1]
         *    - KEY_PREFIX + keyName: 例如 "lock:order:123"
         * 3. ID_PREFIX + Thread.currentThread().getId(): 
         *    - 当前线程的标识，对应Lua脚本中的ARGV[1]
         *    - 例如 "thread:42"，用于验证锁的持有者
         * 
         * 执行流程：
         * 1. Redis服务器接收脚本和参数
         * 2. 原子性执行Lua脚本中的三个操作：获取锁值→比较标识→条件删除
         * 3. 返回执行结果（Long类型）
         */
        stringRedisTemplate.execute(UNLOCK_SCRIPT,
                // KEYS参数：锁在Redis中的key，包装成列表是因为Lua脚本可以支持多个key
                Collections.singletonList(KEY_PREFIX + keyName),
                // ARGV参数：当前线程的标识，用于验证是否是锁的持有者
                ID_PREFIX + Thread.currentThread().getId());
    }
}

// 注释说明：经过以上代码改造后，我们就能够实现"拿锁比锁删锁"的原子性动作了~

这里其实用了静态代码块，因为这样子在类加载的时候自动初始化而且更加清晰直观。关于静态代码块，静态方法，构造方法，构造代码块的知识点我这里再稍微提一下，可以给大家加深一下印象。

我们来看它们的执行顺序

静态代码块是最先执行的，并且只会执行一次（类加载）。

构造代码块的执行在构造函数之前，只有在创建类的时候才会执行。

ok，我们回到redis。

小总结：

基于Redis的分布式锁实现思路：

利用set nx ex获取锁，并设置过期时间，保存线程标示
释放锁时先判断线程标示是否与自己一致，一致则删除锁
特性：
- 利用set nx满足互斥性
- 利用set ex保证故障时锁依然能释放，避免死锁，提高安全性
- 利用Redis集群保证高可用和高并发特性

我们利用添加过期时间，防止死锁问题的发生，但是有了过期时间之后，可能出现误删别人锁的问题，这个问题我们开始是利用删之前通过拿锁，比锁，删锁这个逻辑来解决的，也就是删之前判断一下当前这把锁是否是属于自己的，但是现在还有原子性问题，也就是我们没法保证拿锁比锁删锁是一个原子性的动作，最后通过lua表达式来解决这个问题。