基于Redis实现分布式锁的总结

如何使用redis来实现分布式锁呢？

以商品订单的支付业务为例子，解决在高并发问题下的商品超卖问题。

第一点：怎么锁？

解决思路：使用 redis 中的 setnx 指令来进行加锁的操作，setnx 指令是指如果当前不存在 key 则进行创建，如果存在则不进行操作。以商品的 ID 为 KEY 来进行加锁。

Boolean b = stringRedisTemplate.boundValueOps(productId).setIfAbsent("value");

第二步：加了锁会出现什么问题？

        第一个问题：如果服务器宕机或者故障，那么这个锁就一直不会被释放，那么这个商品就一直无法被购买。

        解决思路：为这个锁设置一个过期时间，避免服务器宕机或者故障导致锁无法被释放。

Boolean b = stringRedisTemplate.boundValueOps(productId).setIfAbsent("value", 2, TimeUnit.SECONDS);

        第二个问题：如果由于网络卡顿，导致锁在订单业务还没执行完毕之前就过期，那么其他的线程此时也会获取到锁，从而对商品进行操作，在此时，线程1的订单业务执行完毕，就会释放锁，此时释放的是线程2的锁，如何避免线程1释放掉线程2的锁？

        解决思路：为每个 key 绑定一个唯一的 value ，在 fianlly 代码块中进行 value 的比较，如果是当前 key 值，则释放锁。

//给存放在redis中的key设置唯一值
String v = UUID.randomUUID().toString().replace("-", "");
//使用redis中的setnx指令进行判断，如果redis中不存在这个key则创建，如果存在就不创建
Boolean b = stringRedisTemplate.boundValueOps("" +productId).setIfAbsent(v, 2, TimeUnit.SECONDS);


 //在finally代码块中比较值并释放锁
 finally {
   String value = stringRedisTemplate.boundValueOps("" +productId).get();
   //如果是当前线程的值则进行key的释放
   if (value != null && value.equals(v)) {
       stringRedisTemplate.delete("" +productId);
   }
}

        第三个问题：在第二个问题的基础上，如果在 finally 代码块中的查询 key 值的过程中，线程1释放了锁，那么此时还是会将线程2的锁释放掉，怎么保证查询和删除两个操作的原子性？

        解决思路：将查询和删除操作写到 lua 脚本文件中，通过 redis 加载 lua 脚本文件，来进行查询和删除的原子性操作。

以下是 lua 脚本文件的编写

-- 以下是redis的lua脚本，相当于redis的指令在redis中进行整体操作
-- keys 和 argv 是俩个要传的参数
if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

在启动类中添加 lua 脚本文件的读取配置类

 @Bean
    public DefaultRedisScript<List> defaultRedisScript(){
        DefaultRedisScript<List> defaultRedisScript = new DefaultRedisScript<>();
        defaultRedisScript.setResultType(List.class);
        defaultRedisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("unlock.lua")));
        return  defaultRedisScript;
    }

以下是 finally 代码块中的代码

 //使用读取lua脚本文件的方式来进行原子性操作
 List<String> list=new ArrayList<>();
 list.add(productId+"");
 //执行lua脚本中的redis指令
 stringRedisTemplate.execute(defaultRedisScript,list,v);

        第四个问题：如果由于网络卡顿，导致锁在订单业务还没执行完毕之前就过期，那么其他的线程此时也会获取到锁，从而对商品进行操作，从而导致商品超卖问题的出现，如何在锁快过期时为锁添加过期时间？

        解决思路：使用看门狗线程，监听锁的过期时间，当锁快要过期时就为锁添加过期时间。

以下是 redis 实现整个分布式锁的代码过程

@Service
public class ProductServiceImpl implements ProductService {
    @Value("${server.port}")
    private String port;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private ProductMapper productMapper;

    @Autowired
    private DefaultRedisScript defaultRedisScript;

    @Override
    public ResultData orderById(int productId, int num) {
        //给存放在redis中的key设置唯一值
        String v = UUID.randomUUID().toString().replace("-", "");
        //使用redis中的setnx指令进行判断，如果redis中不存在这个key则创建，如果存在就不创建
        Boolean b = stringRedisTemplate.boundValueOps("" +productId).setIfAbsent(v, 2, TimeUnit.SECONDS);
        //阻塞锁，当无法获取锁时会一直去尝试获取锁
        while (!b){
            stringRedisTemplate.boundValueOps(""+productId).setIfAbsent(v,2,TimeUnit.SECONDS);
        }
        //自定义非阻塞锁，在一段时间内对key尝试获取，直到设置的条件不成立
        long beginTime = System.currentTimeMillis();
        while (!b && System.currentTimeMillis() < beginTime + 3000) {
            b = stringRedisTemplate.boundValueOps("" +productId).setIfAbsent(v, 2, TimeUnit.SECONDS);
        }
        try {
            if (b) {
                //创建看门狗线程，他是一个独立的线程，不会影响其他的线程
                Thread watchThread=new Thread(new Runnable() {
                    @Override
                    public void run() {
                        //死循环，会一直执行，直到当前用户线程结束
                        while (true){
                            //获取锁的过期时间
                            Long expire = stringRedisTemplate.boundValueOps("" + productId).getExpire();
                            if(expire<2000){
                                //如果锁快过期，则给锁添加过期时间
                                stringRedisTemplate.boundValueOps(""+productId).expire(10,TimeUnit.SECONDS);
                            }
                        }
                    }
                });
                //设置为守护线程模式，当一个进程中只有守护线程时，
                // JVM会自动退出，不会等待其他非守护线程执行完毕。它的作用是保证程序安全退出。
                //在Java中，线程分为守护线程和用户线程。当只有守护线程在运行时，JVM会退出。
                // 而用户线程不会影响JVM的退出。
                watchThread.setDaemon(true);
                watchThread.start();
                //进行订单支付业务
                Product product = productMapper.selectById(productId);
                if (product != null && num <= product.getNumber()) {
                    System.out.println(port + "------>商品被购买了");
                    int number = product.getNumber() - num;
                    //修改库存
                    product.setNumber(number);
                    int count = productMapper.updateById(product);
                    if (count > 0) {
                        return new ResultData(0, "购买成功");
                    } else {
                        return new ResultData(100, "购买失败");
                    }
                } else {
                    return new ResultData(100, "库存不足");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            //在finally代码块中比较值并释放锁
        } finally {
            //以下代码存在查询过程中，线程 1删除了锁的问题
            String value = stringRedisTemplate.boundValueOps("" +productId).get();
            //如果是当前线程的值则进行key的释放
            if (value != null && value.equals(v)) {
                stringRedisTemplate.delete("" +productId);
            }

            //使用读取lua脚本文件的方式来进行原子性操作
            List<String> list=new ArrayList<>();
            list.add(productId+"");
            //执行lua脚本中的redis指令
            stringRedisTemplate.execute(defaultRedisScript,list,v);
        }
        return new ResultData(100, "操作失败");
    }
}