1.问题简介

在《【遇见青山】项目难点：解决超卖问题》一文中，我们使用了synchronized方法解决了单机系统下的超卖问题，但是在集群的情况下，这种锁就会失效

本质原因是集群状态下，不同的服务器的jvm不一致，由不同的锁监视器来控制锁的生成和释放，导致锁失效！依然会存在超卖问题，那么如何解决这个问题呢？

这就需要用到分布式锁🔒了！

---

2.分布式锁分析

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

本方案介绍基于Redis的分布式锁：

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

业务流程图：

---

3.基于Redis实现分布式锁1.0版本

public class SimpleRedisLock implements ILock {

    private String name;

    private StringRedisTemplate stringRedisTemplate;

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    /**
     * 尝试获取锁
     *
     * @param timeoutSec 锁的过期时间，防止死锁
     * @return 是否获取成功锁🔒
     */
    @Override
    public boolean tryLock(long timeoutSec) {

        // 获取线程标识
        long threadId = Thread.currentThread().getId();

        // 获取锁
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(LOCK_KEY + name, threadId + "", timeoutSec, TimeUnit.SECONDS);

        return Boolean.TRUE.equals(success);
    }

    /**
     * 释放锁
     */
    @Override
    public void unlock() {
        stringRedisTemplate.delete(LOCK_KEY + name);
    }
}

在创建新的订单之前，手动获取锁和释放锁：

// 创建锁对象
SimpleRedisLock lock = new SimpleRedisLock("order" + userId, stringRedisTemplate);
// 获取锁
boolean isLock = lock.tryLock(5);
// 获取锁失败，代表当前用户在多次抢券
if (!isLock) {
    return Result.fail("您已经抢过了哦~");
}

try {
    // 为了防止事务失效，这里使用代理对象调用方法
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
    // 返回订单id
    return proxy.createVoucherOrder(voucherId);
} finally {
    // 手动释放锁
    lock.unlock();
}

---

4.基于Redis实现分布式锁2.0版本，解决锁误删问题

锁误删问题，是指当线程1陷入阻塞时，阻塞时间大于锁的过期时间导致锁被提前释放，当线程1脱离阻塞时，执行了释放锁的操作，但是此时释放的锁可能时其他线程的锁，所以在各个线程进行锁释放时要判断释放的到底是不是自己的锁！

业务流程图：

接下来来改进一下1.0的代码：

public class SimpleRedisLock implements ILock {

    private String name;

    private StringRedisTemplate stringRedisTemplate;


    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }


    // 分布式锁的线程标识前缀，防止多个虚拟机线程ID一致，存入同样的redis分布式锁key中的巧合
    private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";

    /**
     * 尝试获取锁
     *
     * @param timeoutSec 锁的过期时间，防止死锁
     * @return 是否获取成功锁🔒
     */
    @Override
    public boolean tryLock(long timeoutSec) {

        // 获取线程标识，随机UUID + 线程id
        String threadId = ID_PREFIX + Thread.currentThread().getId();

        // 获取锁
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(LOCK_KEY + name, threadId + "", timeoutSec, TimeUnit.SECONDS);

        return Boolean.TRUE.equals(success);
    }

    /**
     * 释放锁
     */
    @Override
    public void unlock() {
        // 获取线程标识，随机UUID + 线程id
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        // 获取redis分布式锁中的标识
        String lockId = stringRedisTemplate.opsForValue().get(LOCK_KEY + name);
        // 判断标识是否一致（是否是自己的锁🔒）
        if (threadId.equals(lockId)) {
            // 释放锁
            stringRedisTemplate.delete(LOCK_KEY + name);
        }
    }
}

---

5.基于Redis实现分布式锁3.0版本，解决锁的原子性问题

解决锁的原子性问题是指：当一个线程在执行完判断锁标识之后，准备释放锁之前，恰好发生了阻塞导致锁超时释放，这时如果脱离阻塞状态，由于还没有执行释放锁的操作，导致误释放其他线程的锁！

这时可以使用Lua脚本解决多条命令执行的问题

Redis提供了Lua脚本功能，在一个脚本中编写多条Redis命令，确保多条命令执行时的原子性。Lua是一种编程语言🫁

编写Lua脚本：unlock.lua

-- 比较线程标识与锁中的标识是否一致
if (redis.call('get', KEYS[1]) == ARGV[1]) then
    -- 释放锁
    return redis.call('del',KEYS[1])
end
return 0

改进程序，首先在静态初始化时加载Lua脚本：

// 引入Lua脚本
private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;

static {
    UNLOCK_SCRIPT = new DefaultRedisScript<>();
    UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
    UNLOCK_SCRIPT.setResultType(Long.class);
}

其次，该进释放锁的代码：

/**
 * 释放锁
 */
@Override
public void unlock() {
    // 调用Lua脚本解决释放锁的原子性问题
    stringRedisTemplate.execute(UNLOCK_SCRIPT,
            Collections.singletonList(LOCK_KEY + name),
            ID_PREFIX + Thread.currentThread().getId());

}