一步步带你实现Redis分布式锁

最新推荐文章于 2024-08-13 14:41:03 发布
最新推荐文章于 2024-08-13 14:41:03 发布
阅读量603 收藏 2
点赞数 1
分类专栏： redis 文章标签： redis 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zx110503/article/details/106272003
版权

本文个人博客地址：https://www.leafage.top/posts/detail/20824ZB0N

使用场景：

抢购活动，限量供应；

首先第一步设计：将库存信息放入redis进行缓存；

public class DistributedRedis {

    @Autowired
    private RedisTemplate<String, Integer> redisTemplate;

    private void buyGoods(){
        // 获取key对应的数据
        Integer stock = redisTemplate.opsForValue().get("stock");
        // 如果库存大于0，对库存减1
        if(null != stock && stock > 0){
            int realStock = stock - 1;
            // 将修改后的库存放入redis
            redisTemplate.opsForValue().set("stock", realStock);
            System.out.println("库存扣减成功，当前库存为：" + realStock);
        } else {
            System.out.println("库存扣减失败");
        }
    }
}

问题一：高并发场景下会出现库存扣减异常；

以上代码存在一个问题：当高并发场景下，会有多个请求同时获取到同样的数据，然后进行操作，实际上操作了多次，但是库存只减了一次；
那这样的场景的解决方案有：

  1. 加synchronized锁，示例如下：
public class DistributedRedis {

    @Autowired
    private RedisTemplate<String, Integer> redisTemplate;

    private void buyGoods(){
 		  // 加同步锁
        synchronized (this){
            // 获取key对应的数据
            Integer stock = redisTemplate.opsForValue().get("stock");
            // 如果库存大于0，对库存减1
            if(null != stock && stock > 0){
                int realStock = stock - 1;
                // 将修改后的库存放入redis
                redisTemplate.opsForValue().set("stock", realStock);
                System.out.println("库存扣减成功，当前库存为：" + realStock);
            } else {
                System.out.println("库存扣减失败");
            }
        }

    }
}

问题二：多实例部署，synchronized锁失效的问题；

当服务为单机的情况下，加synchronized是可以解决问题的，但是如果多实例部署，那么这个锁就没有效果了；针对新产生的这个问题，可以通过使用redis.setnx()方法来解决；使用redistemplate，操作的是setIfAbsent()方法：

public class DistributedRedis {

    @Autowired
    private RedisTemplate<String, Integer> redisTemplate;

    private void buyGoods() {
//        synchronized (this){
        String lockKey = "stockLock";
        // 针对多实例部署，可以使用setIfAbsent()方法，这个代码实际是redis.setNx()方法
        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, 119);
        if (null == aBoolean || !aBoolean) {
            return;
        }
        // 获取key对应的数据
        Integer stock = redisTemplate.opsForValue().get("stock");
        // 如果库存大于0，对库存减1
        if (null != stock && stock > 0) {
            int realStock = stock - 1;
            // 将修改后的库存放入redis
            redisTemplate.opsForValue().set("stock", realStock);
            System.out.println("库存扣减成功，当前库存为：" + realStock);
        } else {
            System.out.println("库存扣减失败");
        }
		  // 操作完成之后，删除锁
        redisTemplate.delete(lockKey);
//        }

    }
}

问题三：当方法执行过程中代码执行出现异常，锁无法删除的问题：

当方法执行时，如果中间某一步执行发生异常，那么后面的代码是无法执行到的，那也就是说，redistemplate.delete()是执行不到的；这时候的解决方案是使用try-finally或者try-with-resource来解决，代码示例如下；

public class DistributedRedis {

    @Autowired
    private RedisTemplate<String, Integer> redisTemplate;

    private void buyGoods() {
//        synchronized (this){
        String lockKey = "stockLock";
        try {
            // 针对多实例部署，可以使用setIfAbsent()方法，这个代码实际是redis.setNx()方法
            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, 119);
            if (null == aBoolean || !aBoolean) {
                return;
            }
            // 获取key对应的数据
            Integer stock = redisTemplate.opsForValue().get("stock");
            // 如果库存大于0，对库存减1
            if (null != stock && stock > 0) {
                int realStock = stock - 1;
                // 将修改后的库存放入redis
                redisTemplate.opsForValue().set("stock", realStock);
                System.out.println("库存扣减成功，当前库存为：" + realStock);
            } else {
                System.out.println("库存扣减失败");
            }
            
//        }
        } finally {
            // 操作完成之后，删除锁
            redisTemplate.delete(lockKey);
        }
    }
}

问题四：如果方法执行过程中，服务整个挂掉了，那么加的锁会一直存在的问题；

当方法执行过程中，服务挂掉了，或者重启了，那没有释放掉的锁会一直存在，解决方案是给这个锁设置一个失效时间；

设置失效方法有两种：
  1. 先设置锁，在自行设置失效时间；
  2. 在设置锁的同时（并非真正同时，而是redis自己实现的原子操作）设置失效时间；
public class DistributedRedis {

    @Autowired
    private RedisTemplate<String, Integer> redisTemplate;

    private void buyGoods() {
//        synchronized (this){
        String lockKey = "stockLock";
        try {
            // 针对多实例部署，可以使用setIfAbsent()方法，这个代码实际是redis.setNx()方法
            // 给锁设置失效时间，方法有两种：一种是先设置锁，然后在自行设置失效时间
//            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, 119);
//            redisTemplate.expire(lockKey, 15, TimeUnit.SECONDS);
            // 方法二：在设置锁的同时设置其失效时间
//            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, 119, Duration.of(15, ChronoUnit.SECONDS)); // 此方法是对下面的额方法传入的时间的一个封装
            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, 119, 15, TimeUnit.SECONDS);
            
            if (null == aBoolean || !aBoolean) {
                return;
            }
            // 获取key对应的数据
            Integer stock = redisTemplate.opsForValue().get("stock");
            // 如果库存大于0，对库存减1
            if (null != stock && stock > 0) {
                int realStock = stock - 1;
                // 将修改后的库存放入redis
                redisTemplate.opsForValue().set("stock", realStock);
                System.out.println("库存扣减成功，当前库存为：" + realStock);
            } else {
                System.out.println("库存扣减失败");
            }

//        }
        } finally {
            // 操作完成之后，删除锁
            redisTemplate.delete(lockKey);
        }
    }
}

问题五：当方法还没执行完，锁失效了的问题；

当服务多实例部署是，由于网络，服务器等原因，方法执行时间不等，可能存在在释放锁的时候，这个锁已经失效的情况，或者释放的锁不是本次操作添加的锁，那么这个锁也就失效了；解决方法是在加锁时，添加一个身份标识，在释放锁时，判断这个锁是否自己添加的，示例代码如下：

public class DistributedRedis {

    @Autowired
    private RedisTemplate<String, Integer> redisTemplate;

    private void buyGoods() {
//        synchronized (this){
        String lockKey = "stockLock";
        int nextInt = 0;
        try {
            nextInt = new Random().nextInt(100);
            // 针对多实例部署，可以使用setIfAbsent()方法，这个代码实际是redis.setNx()方法
            // 给锁设置失效时间，方法有两种：一种是先设置锁，然后在自行设置失效时间
//            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, 119);
//            redisTemplate.expire(lockKey, 15, TimeUnit.SECONDS);
            // 方法二：在设置锁的同时设置其失效时间
//            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, 119, Duration.of(15, ChronoUnit.SECONDS)); // 此方法是对下面的额方法传入的时间的一个封装
            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, nextInt, 15, TimeUnit.SECONDS);

            if (null == aBoolean || !aBoolean) {
                return;
            }
            // 获取key对应的数据
            Integer stock = redisTemplate.opsForValue().get("stock");
            // 如果库存大于0，对库存减1
            if (null != stock && stock > 0) {
                int realStock = stock - 1;
                // 将修改后的库存放入redis
                redisTemplate.opsForValue().set("stock", realStock);
                System.out.println("库存扣减成功，当前库存为：" + realStock);
            } else {
                System.out.println("库存扣减失败");
            }

//        }
        } finally {
            // 操作完成之后，删除锁
            Integer lockValue = redisTemplate.opsForValue().get(lockKey);
            if(0 != nextInt && null != lockValue && nextInt == lockValue){
                redisTemplate.delete(lockKey);
            }
        }
    }
}

问题六：失效时间的长短怎么确定，不合适的失效时间如何解决；

当一个方法中使用redis分布式锁，它的失效时间确定多少为合适？这个问题可以通过使用redisson框架来解决，示例代码如下；

public class DistributedRedis {

    @Autowired
    private RedisTemplate<String, Integer> redisTemplate;
    @Autowired
    private Redisson redisson;

    private void buyGoods() {
//        synchronized (this){
        String lockKey = "stockLock";
//        int nextInt = 0;
        RLock lock = redisson.getLock(lockKey);
        try {
            // 默认失效时间为-1，不失效
            lock.lock(15, TimeUnit.SECONDS);
//            nextInt = new Random().nextInt(100);
            // 针对多实例部署，可以使用setIfAbsent()方法，这个代码实际是redis.setNx()方法
            // 给锁设置失效时间，方法有两种：一种是先设置锁，然后在自行设置失效时间
//            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, 119);
//            redisTemplate.expire(lockKey, 15, TimeUnit.SECONDS);
            // 方法二：在设置锁的同时设置其失效时间
//            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, 119, Duration.of(15, ChronoUnit.SECONDS)); // 此方法是对下面的额方法传入的时间的一个封装
//            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent(lockKey, nextInt, 15, TimeUnit.SECONDS);
//
//            if (null == aBoolean || !aBoolean) {
//                return;
//            }
            // 获取key对应的数据
            Integer stock = redisTemplate.opsForValue().get("stock");
            // 如果库存大于0，对库存减1
            if (null != stock && stock > 0) {
                int realStock = stock - 1;
                // 将修改后的库存放入redis
                redisTemplate.opsForValue().set("stock", realStock);
                System.out.println("库存扣减成功，当前库存为：" + realStock);
            } else {
                System.out.println("库存扣减失败");
            }

//        }
        } finally {
            // 操作完成之后，删除锁
//            Integer lockValue = redisTemplate.opsForValue().get(lockKey);
//            if(0 != nextInt && null != lockValue && nextInt == lockValue){
//                redisTemplate.delete(lockKey);
//            }
            lock.unlock();
        }
    }
}
布吉_岛
关注
专栏目录
Redis分布式锁
Mr.xing的博客
01-18 823
什么是分布式锁 在单体应用中锁解决的是控制共享资源访问的问题，分布式锁是解决分布式系统中控制共享资源访问的问题，共享资源的最小粒度从线程变成了进程。一个接口的方法在同一时间只能被一个机器的一个线程执行。 Redis分布式锁 setnx命令：set if not exists，当key不存在时，将key的值设为value。若给key存在，则 SETNX不做任何动作。返回1，说明该进程获得锁，将key的值设为value返回0，说明其他进程已经获得了锁，进程不能进入临界区。 命令格式：setnx lock.
深入理解分布式技术 - Redis 分布式锁解决方案
热门推荐
小工匠
01-31 1万+
文章目录Pre分布式锁特征使用 setnx 实现分布式锁使用 setnx 和 expire 实现使用 set 扩展命令实现分布式锁的高可用集群下分布式锁存在哪些问题Redlock 算法的流程 Pre Redis进阶-细说分布式锁 Redis 可以通过 set key 方式来实现分布式锁，但实际情况要更加复杂，比如如何确保临界资源的串行执行，如何及时释放，都是需要额外考虑的。 那一个完备的分布式锁应该具备哪些特性，以及如何使用 Redis 来一步步优化实现呢？ 分布式锁特征 一个完备的分布式锁，需要支持
一分钟实现分布式锁
03-01
分布式环境下，多台机器上多个进程对一个数据进行操作，如果不做互斥，就有可能出现“余额扣成负数”，或者“商品超卖”的情况，如何实现简易分布式锁，对分布式环境下的临界资源做互斥
Redis实现分布式锁方案
清风
08-21 1149
先来引入一个问题，复习复习以前多线程和数据库的知识。如下所示，有一个Product表，带有库存：使用jmeter测试，开启n多个线程同时去扣减id为1的数据的库存(每次减一)：最终的结果显示库存为负数，明显超卖了（有可能是正数），这是在单线程下的并发安全问题。问题的原因是多个线程同时查询，都查询到库存充足，进入if块了，但库存被扣完了，此时就会超卖。为什么这么写？是因为直接加锁有一点问题——>。②在数据库层面加悲观锁：在第一条查询语句时就加上排他锁，保证了只有一个线程能够同时查询和更新。
Redis的分布式锁详解
最新发布
Lsd2176647391的博客
08-13 2226
（3）为了有效解决既保证锁完全有效性 和 性能高效问题：antirez又提出了“延迟重启”的概念，redis同步到磁盘方式保持默认的每秒1次，在redis崩溃单机后（无论是一个还是所有），先不立即重启它，而是等待TTL时间后再重启，这样的话，这个节点在重启前所参与的锁都会过期，它在重启后就不会对现有的锁造成影响，缺点是在TTL时间内服务相当于暂停状态；分布式事务锁中，为了能够让作为中心节点的存储节点获取锁的持有者，从而避免锁被非持有者误解锁，每个发起请求的 client 节点都必须具有全局唯一的 id。
一步一步实现基于redis的分布式锁
阳
10-18 275
前提 通过多线程请求一个接口，实现抢单的实现。 总数：10 线程数：200 测试方式：Jmeter 无锁状态 在无锁状态下，实现了库存的减少的业务逻辑。测试过程中，在没有并发情况下，redis中的库存数量按照理论逐渐递减。但是当使用Jmeter测试时，线程数量为200时，出现了库存数量重复的现象...
redis 分布式锁
qiyue683209的博客
12-19 238
最近抽空优化了之前已有的redis分布式锁，主要用于解决高并发的问题，比如抢红包，多个人同时操作红包库存，当在库存只剩下1个的时候，一个人的减库存的操作事务没提交，另一个人的查库存操作刚好同步执行，这样就会出现很尴尬的事情，1个红包会被2个人抢走，这个时候，我们就要依托锁，将请求入口锁住，当然锁有很多种方式，这边就记录一下比较好用的redis分布式锁。  方式有很多setNX 、set、incr...
【Redis】分布式锁
qq_39921135的博客
08-06 1455
经过上节课的演示，可以发现在集群模式下synchronized锁失效了，synchronized只能保证单个JVM内部的多个线程之间的互斥，而没有办法让我们集群下的多个JVM进程之间互斥，要想解决这个问题，我们必须使用分布式锁。
Redis之分布式锁
猎户星座
10-31 825
# 基于 Redis 实现分布式锁的三种方案 用 Redis 实现分布式锁的正确姿势（实现一） 用 Redisson 实现分布式可重入锁（RedissonLock）（实现二） 用 Redisson 实现分布式锁(红锁 RedissonRedLock)（实现三） 本文主要探讨基于 Redis 实现分布式锁的方案，主要分析并对比了以上三种方案，并大致分析了 Redisson 的 Redisson...
Redis分布式锁存在的问题
小黑说Java
01-03 2372
在很多场景中，我们为了保证数据的最终一致性，需要很多的技术方案来支持，比如分布式事务、分布式锁等。
SpringBoot 中利用 Redisson 实现分布式锁
程序员光剑
07-30 1896
Redisson 是一款高级的分布式协调Redis客户端，其提供了一系列分布式数据结构和实用工具类，可以帮助开发人员快速、高效地处理分布式系统中的一些功能，比如缓存、分布式锁、分布式消息等。为了方便使用 Redisson 的功能，Spring Boot 在提供starter包的同时，也为我们提供了对 Redisson 的集成支持。本文将从 Spring Boot 中如何利用 Redisson 提供的分布式锁技术实现简单的分布式场景中的锁机制。
深入浅出：Redis 分布式锁原理与实现 （一）
weixin_42215137的博客
08-31 490
Redis 分布式锁原理与实现 Java 应用在多线程环境下，我们可以通过 Java 内存模型实现同步，比如 Lock，synchronized 等， 但是在分布式环境下，特别是现在微服务盛行的时代，服务为了高可用会做集群。在这样的情况下每个服务都有自己独立进程，当高并发的情况下，会存在同步问题，本文主要记录自己学习Redis分布式锁的过程。从浅到深一步步通过代码去分析。 1. 什么场景下...
Springboot基于Redisson实现Redis分布式可重入锁【案例到源码分析】
Java技术攻略的博客
05-05 245
我们在实现使用Redis实现分布式锁，最开始一般使用进行加锁，使用Lua脚本保证原子性进行实现释放锁。这样手动实现比较麻烦，对此Redis官网也明确说Java版使用Redisson来实现。小编也是看了官网慢慢的摸索清楚，特写此记录一下。从官网到整合Springboot到源码解读，以单节点为例小编的理解都在注释里，希望可以帮助到大家！！这样大家就跟着小编走完了一遍底层源码，是不是感觉自己又行了，哈哈哈。小编走下来一遍觉得收货还是蛮大的，以前不敢点进去源码，进去就懵逼了，所以人要大胆的向前迈出第一步。
redis的分布式锁
qiulinsama的博客
12-28 529
Distributed locks with Redis   Distributed locks are a very useful primitive in many environments where different processes must operate with shared resources in a mutually exclusive way.   分布式锁在很多场...
Redis的分布式锁
m0_58524181的博客
09-22 691
Redis的分布式锁
Redis 分布式锁
Reid的专栏
09-13 409
参考： 官方文档 给出的实现 官方文档翻译版 Redis 深度历险：核心原理与应用实践 Redis单节点实现 当resource_name不能存在时才能获取到锁，同时设置超时时间防止出现死锁。这时my_random_value是为了再删除时当前客户端的锁不会被其他客户端删除。 获取锁： SET resource_name my_random_value NX PX 30000 ...
如何优雅地用Redis实现分布式锁
weixin_33736048的博客
08-29 323
什么是分布式锁 在学习Java多线程编程的时候，锁是一个很重要也很基础的概念，锁可以看做是多线程情况下访问共享资源的一种线程同步机制。这是对于单进程应用而言的，即所有线程都在同一个JVM进程里的时候，使用Java语言提供的锁机制可以起到对共享资源进行同步的作用。如果分布式环境下多个不同线程需要对共享资源进行同步，那么用Java的锁机制就无法实现了，这个时...
Scrapy-Redis分布式爬虫搭建详解及原理
本文将引导读者一步步搭建Scrapy-redis分布式爬虫，理解其内部工作机制，以及如何根据实际需求调整配置以实现高效的分布式爬取。这对于想要利用Scrapy进行大规模数据抓取的开发者来说，是一份极具实用价值的教程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值