redis分布式锁实战

最新推荐文章于 2024-07-25 15:14:14 发布
最新推荐文章于 2024-07-25 15:14:14 发布
阅读量323 收藏 1
点赞数
文章标签： redis分布式锁实战
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012222011/article/details/124862179
版权

单机架构场景解决并发问题

1: 无锁版商品购买

public boolean snatch(int goodsId){

        //获取商品库存
        String stockStr = stringRedisTemplate.opsForValue().get(String.valueOf(goodsId));
        int stock = Integer.parseInt(stockStr);

        if(stock > 0){
            System.out.println("buy success, stock :" + stock--);
            stringRedisTemplate.opsForValue().set(String.valueOf(goodsId),String.valueOf(stock));
        }else{
            System.out.println("stock is zero");
            return false;
        }

        return true;
}

问题 : 当大量用户抢购时候,非常容易造成某个商品的重复出售问题; 不会有超卖问题;redis是单线程的; 

2: Lock加锁版本商品

public boolean snatch1(int goodsId){

        Lock lock = new ReentrantLock();
        //获取商品库存
        String stockStr = stringRedisTemplate.opsForValue().get(String.valueOf(goodsId));
        int stock = Integer.parseInt(stockStr);

        lock.lock();
        if(stock > 0){
            System.out.println("buy success, stock :" + stock--);
            stringRedisTemplate.opsForValue().set(String.valueOf(goodsId),String.valueOf(stock));
        }else{
            System.out.println("stock is zero");
            return false;
        }
        lock.unlock();
        return true;
}

问题 : 没锁住获取库存的代码,导致很多用户同样会出现问题

3: synchronized加锁

public synchronized boolean snatch2(int goodsId){

        //获取商品库存
        String stockStr = stringRedisTemplate.opsForValue().get(String.valueOf(goodsId));
        int stock = Integer.parseInt(stockStr);

        if(stock > 0){
            System.out.println("buy success, stock :" + stock--);
            stringRedisTemplate.opsForValue().set(String.valueOf(goodsId),String.valueOf(stock));
        }else{
            System.out.println("stock is zero");
            return false;
        }
        return true;
}

问题 : 锁住了整个方法,但是导致单体下不适用抢购代码

4: nginx搭建演示

upstream redis{ 
server 192.168.25.111:8080; 
server 192.168.25.111:8081; 
server 192.168.25.111:8082; 
} 

location /dxx 
{ 
    proxy_pass http://redis/; 
}

 

集群架构场景解决并发问题

1: 基于SETNX锁

https://redis.io/commands/setnx/

public boolean snatch3(int goodsId){

        //redis的setnx命令;如果存在这个值,就不会再设置了;
        Boolean locked = stringRedisTemplate.opsForValue().setIfAbsent("lock", "ldx");

        if(!locked){ //没拿到锁,代表获取商品失败
            return false;
        }

        //获取商品库存
        String stockStr = stringRedisTemplate.opsForValue().get(String.valueOf(goodsId));
        int stock = Integer.parseInt(stockStr);

        if(stock > 0){
            System.out.println("buy success, stock :" + stock--);
            stringRedisTemplate.opsForValue().set(String.valueOf(goodsId),String.valueOf(stock));
        }else{
            System.out.println("stock is zero");
            return false;
        }

        //解锁
        stringRedisTemplate.delete("lock");

        return true;
    }

问题 : 有死锁bug,当代码出现异常,不会进行解锁

2: try解决死锁BUG

public boolean snatch4(int goodsId){

        //redis的setnx命令;如果存在这个值,就不会再设置了;
        Boolean locked = stringRedisTemplate.opsForValue().setIfAbsent("lock", "ldx");

        if(!locked){ //没拿到锁,代表获取商品失败
            return false;
        }

        try{
            //获取商品库存
            String stockStr = stringRedisTemplate.opsForValue().get(String.valueOf(goodsId));
            int stock = Integer.parseInt(stockStr);

            if(stock > 0){
                System.out.println("buy success, stock :" + stock--);
                stringRedisTemplate.opsForValue().set(String.valueOf(goodsId),String.valueOf(stock));
            }else{
                System.out.println("stock is zero");
                return false;
            }
            return true;
        }finally {
            stringRedisTemplate.delete("lock");
        }
}

问题 : 多个商品之间,拥有同样的锁;如果是不同商品,会把其他人的锁给解掉

3: 多商品锁BUG

public boolean snatch5(int goodsId){

        //每个商品都是自己单独的锁
        Boolean locked = stringRedisTemplate.opsForValue().setIfAbsent(String.valueOf(goodsId), "ldx");

        if(!locked){ //没拿到锁,代表获取商品失败
            return false;
        }

        try{
            //获取商品库存
            String stockStr = stringRedisTemplate.opsForValue().get(goodsId+"stock");
            int stock = Integer.parseInt(stockStr);

            if(stock > 0){
                System.out.println("buy success, stock :" + stock--);
                stringRedisTemplate.opsForValue().set(goodsId+"stock",String.valueOf(stock));
            }else{
                System.out.println("stock is zero");
                return false;
            }
            return true;
        }finally {
            //释放锁
            stringRedisTemplate.delete(String.valueOf(goodsId));
        }
    }

问题 : 如果程序执行时,加上锁.这时候有一台机器重启了,导致代码没有解锁

4: 添加超时机制,解决被锁问题

public boolean snatch6(int goodsId){

        //设置超时时间,指定5秒释放锁;
        //Boolean locked = stringRedisTemplate.opsForValue().setIfAbsent(String.valueOf(goodsId), "ldx");
        //stringRedisTemplate.expire(String.valueOf(goodsId),5, TimeUnit.SECONDS);

        //保证原子性
        Boolean locked = stringRedisTemplate.opsForValue().setIfAbsent(String.valueOf(goodsId), "ldx",5, TimeUnit.SECONDS);

        if(!locked){ //没拿到锁,代表获取商品失败
            return false;
        }

        try{
            //获取商品库存
            String stockStr = stringRedisTemplate.opsForValue().get(String.valueOf(goodsId));
            int stock = Integer.parseInt(stockStr);

            if(stock > 0){
                System.out.println("buy success, stock :" + stock--);
                stringRedisTemplate.opsForValue().set(String.valueOf(goodsId),String.valueOf(stock));
            }else{
                System.out.println("stock is zero");
                return false;
            }
            return true;
        }finally {
            //释放锁
            stringRedisTemplate.delete(String.valueOf(goodsId));
        }
    }

一般的场景下,这样的代码已经可以使用了.基本上很难复现问题,就算有问题,也直接修改数据库排查就好了.但是在真实的互联网大并发的场景下,这个肯定是不行的.因为他们可以达到1s生成1万甚至10万订单的情况.

问题 : 多个请求依次来进行处理,其中某一个请求处理时间需要 10s时间, 第二个请求需要8s时间,第三个请求需要4s时间;但是当前锁的超时时间是5s;可能会导致循环交替解锁,进而引发锁失效的逻辑BUG.

5: 解决锁失效问题

public boolean snatch7(int goodsId){

        //设置超时时间,指定5秒释放锁;
        //Boolean locked = stringRedisTemplate.opsForValue().setIfAbsent(String.valueOf(goodsId), "ldx");
        //stringRedisTemplate.expire(String.valueOf(goodsId),5, TimeUnit.SECONDS);

        //定义一个随机UUID
        String lockValue = "lockldx" + System.currentTimeMillis() + Math.random() + goodsId;

        //保证原子性
        Boolean locked = stringRedisTemplate.opsForValue().setIfAbsent(String.valueOf(goodsId), lockValue,5, TimeUnit.SECONDS);

        if(!locked){ //没拿到锁,代表获取商品失败
            return false;
        }

        try{
            //获取商品库存
            String stockStr = stringRedisTemplate.opsForValue().get(goodsId+"stock");
            int stock = Integer.parseInt(stockStr);

            if(stock > 0){
                System.out.println("buy success, stock :" + stock--);
                stringRedisTemplate.opsForValue().set(goodsId+"stock",String.valueOf(stock));
            }else{
                System.out.println("stock is zero");
                return false;
            }
            return true;
        }finally {
            //释放锁
            if(lockValue.equals(stringRedisTemplate.opsForValue().get(String.valueOf(goodsId)))){
                stringRedisTemplate.delete(String.valueOf(goodsId));
            }
        }
    }

问题 : 这样解决了自己释放自己的锁的问题,但是没有本质上解决这个超时时间控制的问题

6: 刷新超时时间

public boolean snatch8(int goodsId){

        //设置超时时间,指定5秒释放锁;
        //Boolean locked = stringRedisTemplate.opsForValue().setIfAbsent(String.valueOf(goodsId), "ldx");
        //stringRedisTemplate.expire(String.valueOf(goodsId),5, TimeUnit.SECONDS);

        //定义一个随机UUID
        String lockValue = null;
        try {
            lockValue = "lockldx" + System.currentTimeMillis() + Math.random() + InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            lockValue = UUID.randomUUID().toString();
        }

        int locktime = 5;//超时时间,单位s

        //保证原子性
        Boolean locked = stringRedisTemplate.opsForValue().setIfAbsent(String.valueOf(goodsId), lockValue,locktime, TimeUnit.SECONDS);

        if(!locked){ //没拿到锁,代表获取商品失败
            return false;
        }

        String lockValue2 = lockValue;

        try{
            long now = System.currentTimeMillis();//获取锁的时间
            //开启线程,去对过期时间实时扫描
            Thread th = new Thread(){
                public void run() {

                    while (true){

                        //线程是否中断
                        if(Thread.currentThread().isInterrupted()){
                            break;
                        }

                        //如果获取到了,代表已经超时了
                        stringRedisTemplate.opsForValue().setIfAbsent(String.valueOf(goodsId), lockValue2, locktime/2, TimeUnit.SECONDS);
                    }
                }
            };

            //获取商品库存
            String stockStr = stringRedisTemplate.opsForValue().get(goodsId+"stock");
            int stock = Integer.parseInt(stockStr);

            if(stock > 0){
                System.out.println("buy success, stock :" + stock--);
                stringRedisTemplate.opsForValue().set(goodsId+"stock",String.valueOf(stock));
                //th.stop();
                th.interrupt();
            }else{
                System.out.println("stock is zero");
                //th.stop();
                th.interrupt();
                return false;
            }
            return true;
        }finally {
            //释放锁
            if(lockValue.equals(stringRedisTemplate.opsForValue().get(String.valueOf(goodsId)))){
                stringRedisTemplate.delete(String.valueOf(goodsId));
            }
        }
    }

问题 : 这种方案初步看起来没问题,但是经不起推敲,因为线程的不可控以及其他的处理.所以我们使用开源组件Redisson成熟的方案

7: 基于Redisson实现

public boolean snatch8(int goodsId){

        //定义一个随机UUID
        String lockValue = null;
        try {
            lockValue = "lockldx" + System.currentTimeMillis() + Math.random() + InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
            lockValue = UUID.randomUUID().toString();
        }

        int locktime = 5;//超时时间,单位s
        RLock lock = redissonClient.getLock(lockValue);
        lock.lock(locktime,TimeUnit.SECONDS);

        //lock.tryLock(locktime,TimeUnit.SECONDS);//不阻塞

        try{
            //获取商品库存
            String stockStr = stringRedisTemplate.opsForValue().get(goodsId+"stock");
            int stock = Integer.parseInt(stockStr);

            if(stock > 0){
                System.out.println("buy success, stock :" + stock--);
                stringRedisTemplate.opsForValue().set(goodsId+"stock",String.valueOf(stock));

            }else{
                System.out.println("stock is zero");

                return false;
            }
            return true;
        }finally {
            //释放锁
            lock.unlock();
        }
    }

 

 

Hide on jdk
关注
Redis——Redis分布式锁原理与实战
庄小焱
03-13 633
分布式应用进行逻辑处理时经常会遇到并发问题。比如一个操作要修改用户的状态，修改状态需要先读出用户的状态，在内存里进行修改，改完了再存回去。如果这样的操作同时进行了，就会出现并发问题，因为读取和保存状态这两个操作不是原子的。（ Wiki 解释：所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch 线程切换。）这个时候就要使用到分布式锁来限制程序并发的执行。
Redis分布式锁的原理以及如何续期
2401_84002294的博客
04-26 413
看完美团、字节、腾讯这三家的面试问题，是不是感觉问的特别多，可能咱们又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。开篇有提及我可是足足背下了1000道题目，多少还是有点用的呢，我看了下，上面这些问题大部分都能从我背的题里找到的，所以今天给大家分享一下互联网工程师必备的面试1000题。注意不论是我说的互联网面试1000题，还是后面提及的算法与数据结构、设计模式以及更多的Java学习笔记等，皆可分享给各位朋友互联网工程师必备的面试1000题而且从上面三家来看，算法与数据结构是必备不可少的。
Redis分布式锁之实战
li_tiantian的博客
12-18 191
一、pom依赖 <dependency> <groupId>tf56.redis</groupId> <artifactId>redis-client</artifactId> <version>1.0.0</version&gt...
Redis实现分布式锁的7种方案，及正确使用姿势！
最新发布
weixin_47539928的博客
07-25 827
Redis实现分布式锁的7种方案，及正确使用姿势！
Redis分布式锁实战
ibigboy
07-14 449
大家好，我是walking，原文首发于公众号编程大道。感谢你打开这篇文章，请认真阅读下去吧。 今天我们聊聊redis的一个实际开发的使用场景，那就是大名鼎鼎的分布式锁。 啥是分布式锁？ 我们学习 Java 都知道锁的概念，例如基于 JVM 实现的同步锁 synchronized，以及 jdk 提供的一套代码级别的锁机制 lock，我们在并发编程中会经常用这两种锁去保证代码在多线程环境下运行的正确性。但是这些锁机制在分布式场景下是不适用的，原因是在分布式业务场景下，我们的代码都是跑在不同的JV...
redis实战---分布式锁--实战篇
郝老三~~~~~~~~~~~~~
04-04 839
通过本篇文章，我们了解到了如何实现redis的分布式锁。学习了如何使用Redisson进行分布式锁，并且解决了锁的续命问题。redis实战。
Redis实战——分布式锁
qq_59212867的博客
12-03 2182
Redis实战——分布式锁的原理及实现方法
分布式锁——Redis分布式锁
m0_49271078的博客
11-11 249
概述 在高并发环境下，必然会面临多线程对共享资源的竞争问题，如果不进行控制会出现一些异常行为。单机环境下可以使用Synchronized、ReentrantLock等JDK提供的锁来实现多线程对共享资源的互斥访问，但现在的应用大都是集群部署，针对这种跨JVM的情况如何实现来解决互斥访问的问题？这就需要用到分布式锁来进行控制。常见的分布式锁实现方式主要有数据库实现、Redis实现、Zookeeper实现，今天主要对Redis分布式锁进行探究。 Redis 分布式锁 1、加锁流程 SetNX key val
04-大厂生产级Redis高并发分布式锁实战-ev.rar
03-08
04-大厂生产级Redis高并发分布式锁实战_ev.rar04-大厂生产级Redis高并发分布式锁实战_ev.rar04-大厂生产级Redis高并发分布式锁实战_ev.rar04-大厂生产级Redis高并发分布式锁实战_ev.rar04-大厂生产级Redis高并发...
redis分布式锁实践
weixin_30497527的博客
05-06 308
分布式锁在多实例部署,分布式系统中经常会使用到,这是因为基于jvm的锁无法满足多实例中锁的需求,本篇将讲下redis如何通过Lua脚本实现分布式锁,不同于网上的redission,完全是手动实现的 我们先来看一个无锁的情况下会导致什么问题: 这是一个普通的更新用户年龄的功能,各层代码如下,访问controller层,一个更新,一个查询 这是service层,我们使用cont...
Redis分布式锁简单实战
FightingITPanda的博客
11-04 738
redis就话不多说了，上干货。。 1、引包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.3</version> </dependency> <dependency> <groupId
Redis分布式锁的实践
晴天
12-29 833
首先说一下场景,不根据实际场景讲的技术都是吹流弊,没人反对吧,咳咳 医院挂号,需要尽量高效的显示最新的数据,根据不同的科室设置不同的缓存时间,因为科室的热门程度也不一样嘛,这里本次只分享我学习的一些心得. 思路:号源的缓存是30分钟,然后在第25的时候,如果还有患者访问某个部门的号源,就开启一条异步线程直接查询最新的号源,重新放入缓存中.如果没有,就直接让缓存失效,这样就区...
Redis分布式锁的实战解析
qq_43383307的博客
08-16 301
Redis分布式锁
六 Redis分布式锁实战
东风麦芽糖
11-19 309
Redis分布式锁的实现 分布式下redis解决方案redisson
Redis分布式锁，开发实战
u011091199的博客
05-21 422
背景         项目的定时任务，出现重复执行的情况。由于解决时间非常紧急。打算用redis自带的分布式锁 SETNX key value设置键的值，仅当键不存在时          redis官方文档        SETNX key value 将 key 的值设为 value ，当且仅当 key 不存在。 若给定的 key 已经存在，则 SETNX 不做任
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值