redis分布式锁案例分析

最新推荐文章于 2023-08-18 16:13:18 发布

柒间

最新推荐文章于 2023-08-18 16:13:18 发布

阅读量553

点赞数

分类专栏： Redis 文章标签： redis

本文链接：https://blog.csdn.net/qq_43663493/article/details/127158583

版权

Redis 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Case 1
未使用锁：

    @RequestMapping("/deduct_stock1")
    public String deductStock1() {

        //获取库存值
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock")); // jedis.get("stock")
        if (stock > 0) {
            int realStock = stock - 1;
            stringRedisTemplate.opsForValue().set("stock", realStock + ""); // jedis.set(key,value)
            System.out.println("扣减成功，剩余库存:" + realStock);
        } else {
            System.out.println("扣减失败，库存不足");
        }
        return "end";

    }

假设：key = stock ; value = 500
存在并发问题：会发现如果大量线程同时访问，扣减库存的方法时。在某个很小的时间内。获取的库存都是相同的值500.如果此时有10线程调用该方法时。库存为500，那么这10个线程执行完过后。库存量就为499.
这就出现超卖问题了。
Case 2

添加Jvm级别的锁： 
    @RequestMapping("/deduct_stock2")
    public String deductStock2() {
        synchronized (this){
            //获取库存值
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock")); // jedis.get("stock")
            if (stock > 0) {
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock", realStock + ""); // jedis.set(key,value)
                System.out.println("扣减成功，剩余库存:" + realStock);
            } else {
                System.out.println("扣减失败，库存不足");
            }
        }
        return "end";
    }

synchronized 此时如果当前的项目是部署在单机上的（只部署在一台服务器上），那就可以实现一个。如果是集群，锁的生效只有在当前服务器的进程上生效。
Case 3
使用redis中的setnx();设计一个简单的入门级别分布式锁

    /**
     *  使用redis中的setnx();设计一个简单的入门级别分布式锁
     *  
     * @return
     */
    @RequestMapping("/deduct_stock3")
    public String deductStock3() {
        String localKey = "lock:product:0001";
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(localKey, "true");
        if (!aBoolean){
            return "当前系统繁忙";
        }
        try{
            //获取库存值
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock")); // jedis.get("stock")
            if (stock > 0) {
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock", realStock + ""); // jedis.set(key,value)
                System.out.println("扣减成功，剩余库存:" + realStock);
            } else {
                System.out.println("扣减失败，库存不足");
            }
        }finally {
            stringRedisTemplate.delete(localKey);
        }
        return "end";
    }

存在的问题：
如果中间的任何一个一部分逻辑抛出了异常，那么就不会执行delete(localKey);的操作。那之后所有的线程都将加锁不成功。也就不会执行后面的业务代码。
优化：
在finally{}中进行delete(localKey)操作。
存在问题：
锁没有释放，宕机了的情况
Case 4
解决case3中存在的宕机没有释放锁的问题

    @RequestMapping("/deduct_stock4")
    public String deductStock4() {
        String localKey = "lock:product:0001";
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(localKey, "true");
        stringRedisTemplate.expire(localKey,10,TimeUnit.SECONDS);
        if (!aBoolean){
            return "当前系统繁忙";
        }
        try{
            //获取库存值
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock")); // jedis.get("stock")
            if (stock > 0) {
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock", realStock + ""); // jedis.set(key,value)
                System.out.println("扣减成功，剩余库存:" + realStock);
            } else {
                System.out.println("扣减失败，库存不足");
            }
        }finally {
            stringRedisTemplate.delete(localKey);
        }
        return "end";
    }

设置一个过期时间：
存在的问题：存在原子性问题。
原因：还没有执行到expire()时就宕机了

Case 5
解决枷锁时的原子性问题
解决办法：在枷锁时就设置超时时间，也就是枷锁和设置超时时间是原子操作

    @RequestMapping("/deduct_stock5")
    public String deductStock5() {
        String localKey = "lock:product:0001";
        //这条命令能够保证原子性
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(localKey, "true",10,TimeUnit.SECONDS);
        if (!aBoolean){
            return "当前系统繁忙";
        }
        try{
            //获取库存值
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock")); // jedis.get("stock")
            if (stock > 0) {
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock", realStock + ""); // jedis.set(key,value)
                System.out.println("扣减成功，剩余库存:" + realStock);
            } else {
                System.out.println("扣减失败，库存不足");
            }
        }finally {
            stringRedisTemplate.delete(localKey);
        }
        return "end";
    }

存在问题：如果系统并发量不是特别的大，问题不大。并发特别大的时候依然存在超卖问题。
高并发（每秒几千上万访问量）的场景下存在严重的并发问题：
lock-------------- > -----------delete
假设某个请求A的时间超过了超时时间（10s）（锁失效了）,此时该线程A还没有执行delete方法。
另一个线程B这时候就可以加锁成功了，但是这时候线程A执行了delete方法。但是这时候线程A释放的锁是线程B的。
这时候在极端情况下就会出现请求A释放请求B的锁，B释放C的，C释放D的，… 最后就会导致大量的超卖问题。
Case 6
该如何解决 deductStock5（）中存在的问题。
分析：问题存在的根本原因就是在执行delete方法的时候。自己的锁被其他的线程释放了。
解决办法：给每个线程生成一个唯一id.例如使用uuid. 在最后释放锁的时候判断是否是自己的锁。如果是自己的才释放。
注意：不要使用线程id,不同的服务器可能有相同的线程id

    @RequestMapping("/deduct_stock6")
    public String deductStock6() {
        String localKey = "lock:product:0001";
        String uuid = UUID.randomUUID().toString();
        //这条命令能够保证原子性
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(localKey, uuid,10,TimeUnit.SECONDS);
        if (!aBoolean){
            return "当前系统繁忙";
        }
        try{
            //获取库存值
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock")); // jedis.get("stock")
            if (stock > 0) {
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock", realStock + ""); // jedis.set(key,value)
                System.out.println("扣减成功，剩余库存:" + realStock);
            } else {
                System.out.println("扣减失败，库存不足");
            }
        }finally {
            if (uuid.equals(stringRedisTemplate.opsForValue().get(localKey))){
                stringRedisTemplate.delete(localKey);
            }
        }
        return "end";
    }

存在问题：存在原子性问题

            if (uuid.equals(stringRedisTemplate.opsForValue().get(localKey))){
            
            
            // 
            
                stringRedisTemplate.delete(localKey);
            }

上面的代码中不是原子的。在当前线程执行完if判断却还没有执行delete操作的时候。当前锁过期了。
又可能会出现超卖问题。当前的线程释放了其他线程的锁

解决方式：
1.锁续命（实现不容易）
使用一个分线程，使用定时任务，每过一段时间，判断业务的主线程有没有结束（是否还加着锁）。如果还加着锁，将锁的超时时间重新设置。
2.使用现成的例如redisson
Case 7

    @RequestMapping("/deduct_stock7")
    public String deductStock7() {
        String lockKey = "lock:product:0001";
        //获取锁对象
        RLock redissonLock = redisson.getLock(lockKey);
        //加分布式锁
        redissonLock.lock();
        try {
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock")); // jedis.get("stock")
            if (stock > 0) {
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock", realStock + ""); // jedis.set(key,value)
                System.out.println("扣减成功，剩余库存:" + realStock);
            } else {
                System.out.println("扣减失败，库存不足");
            }
        } finally {
            //解锁
            redissonLock.unlock();
        }
        return "end";
    }

核心使用lua脚本

    <T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
        internalLockLeaseTime = unit.toMillis(leaseTime);

        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
                  "if (redis.call('exists', KEYS[1]) == 0) then " +
                      "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                      "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                      "return nil; " +
                  "end; " +
                  "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                      "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                      "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                      "return nil; " +
                  "end; " +
                  "return redis.call('pttl', KEYS[1]);",
                    Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
    }

Redis Lua脚本
Redis在2.6推出了脚本功能，允许开发者使用Lua语言编写脚本传到Redis中执行。使用脚本的好处如下:
1、减少网络开销：本来5次网络请求的操作，可以用一个请求完成，原先5次请求的逻辑放在redis服务器上完成。使用脚本，减少了网络往返时延。这点跟管道类似。
2、原子操作：Redis会将整个脚本作为一个整体执行，中间不会被其他命令插入。管道不是原子的，不过redis的批量操作命令(类似mset)是原子的。
3、替代redis的事务功能：redis自带的事务功能很鸡肋，而redis的lua脚本几乎实现了常规的事务功能，官方推荐如果要使用redis的事务功能可以用redis lua替代。

柒间

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
redis分布式锁案例分析

3、替代redis的事务功能：redis自带的事务功能很鸡肋，而redis的lua脚本几乎实现了常规的事务功能，官方推荐如果要使用redis的事务功能可以用redis lua替代。如果是集群，锁的生效只有在当前服务器的进程上生效。1、减少网络开销：本来5次网络请求的操作，可以用一个请求完成，原先5次请求的逻辑放在redis服务器上完成。管道不是原子的，不过redis的批量操作命令(类似mset)是原子的。这时候在极端情况下就会出现请求A释放请求B的锁，B释放C的，C释放D的，…上面的代码中不是原子的。
复制链接

扫一扫