从redis分布式锁得到的 “大家来找茬“ 的思考习惯

今天药忘吃喽~ 2022-11-06 03:54 113阅读 0赞

测试redis分布式锁的环境：三个model分别是

consumer9010，provider9011，provider9012

本文章主要是来说明 “大家来找茬” 的重要性，还有体现我们做事的严谨性。程序1.0-5.0版不能拿来使用，仅仅用于"分析问题"而使用，如果用在实际场景，还会有很多bug出现。程序6.0版，我们使用Redission就可以使用在我们的业务场景里边

我们是通过consumer9010客户端模块，通过RestTemplate来访问provider9011和provider9012模块，并且配置了负载均衡

现在，我们写一个高并发的购买商品的业务

# 程序1.0版：没有锁 #

在provider9011和provider9012编写同样的代码，同样是BuyController

@RestController
    public class BuyController {
        @Autowired
        StringRedisTemplate stringRedisTemplate;
    
        @Value("${server.port}")
        private String serverPort;
    
        @GetMapping(value = "/buy/{id}")
        public String buy(@PathVariable("id")Integer id){
    
            String result = stringRedisTemplate.opsForValue().get("goods");
            int goodsNumber = result == null ? 0 : Integer.parseInt(result);
            if(goodsNumber > 0){
                int realNumber = goodsNumber - 1;
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realNumber));
                System.out.println("成功购买到商品，库存还剩下："+realNumber+"件"+"\t 服务提供端口"+serverPort);
    
    
                return "成功购买商品，库存还剩下："+realNumber+" 件"+"\t 服务提供端口"+serverPort;
            }else{
                System.out.println("商品已经售完/活动结束/调用超时，欢迎下次光临......."+"\t 服务提供端口"+serverPort);
            }
    
            return "nacos registry, serverPort: " + serverPort + "\t id" + id + "\n"
                    + "商品已经售完/活动结束/调用超时，欢迎下次光临.......";
    
        }
    
    }

我们使用Jmeter模拟100个用户并发测试，出现超卖现象，爽死了，买一送二，一个机子就出现了超卖现象

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 1][]

# 程序2.0版：分别加上synchronized锁 #

@GetMapping(value = "/buy/{id}")
        public String buy(@PathVariable("id")Integer id){
    
            synchronized (this){
                String result = stringRedisTemplate.opsForValue().get("goods");
                int goodsNumber = result == null ? 0 : Integer.parseInt(result);
                if(goodsNumber > 0){
                    int realNumber = goodsNumber - 1;
                    stringRedisTemplate.opsForValue().set("goods",String.valueOf(realNumber));
                    System.out.println("成功购买到商品，库存还剩下："+realNumber+"件"+"\t 服务提供端口"+serverPort);
    
    
                    return "成功购买商品，库存还剩下："+realNumber+" 件"+"\t 服务提供端口"+serverPort;
                }else{
                    System.out.println("商品已经售完/活动结束/调用超时，欢迎下次光临......."+"\t 服务提供端口"+serverPort);
                }
    
                return "nacos registry, serverPort: " + serverPort + "\t id" + id + "\n"
                        + "商品已经售完/活动结束/调用超时，欢迎下次光临.......";
            }
    
    
        }

我们再次测试100个用户并发请求，但是这次把线程组的Ramp-up periok设置为0秒，就是以最快的速度一窝蜂以100个线程去请求资源

![20210307214945318.png][]

两台机子都买了9851和9849，虽然在一台机子上没有出现 "买一送一" 的现象，不过整体来说，还是很爽，又买一送一了~~~，所以在分布式微服务架构的系统里边，不能使用单机版的锁

![20210307215036444.png][]

![20210307215050368.png][]

# 程序3.0版，加上标识，代表redis的锁 #

加上的关键代码：

Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK,value,10L, TimeUnit.SECONDS);

finally {
        stringRedisTemplate.delete(REDIS_LOCK);
    }

①设置锁的标识以后，为什么要设置锁的过期时间？假设不设置过期时间，万一线程执行在try的代码块以内的时候，就宕机了，根本就没有执行finally代码块，锁就不会被释放，资源没有释放，其它线程就得不到服务了，一直卡死。。。

②为什么要把代码写成一行？这是为了保证原子性。如果把设置锁标识和设置锁过期时间的代码分开来写会怎么样？假设A线程恰好执行到这行设置锁标识的代码，就刚好宕机了，这时候，压根儿就没有执行设置过期时间的操作，那么这时候，跟第①的情况是一样的，锁没有被释放，其它线程卡死在那儿

③加了过期时间以后，无论如何，redis自动会帮你解锁

### ④设置了锁过期时间以后，引发新的问题~，假设A线程加了第一把锁，其值叫ALock，由于A线程在try代码块执行下单业务的时候，要请求别的模块，别的模块出了点问题，于是需要12秒才可以完成所有业务，然而，由于过期时间只有10秒，恰好在10秒的时候，锁被自动释放了，B线程发现，诶~！爽了，没锁！！我进去了，于是加上了值叫BLock的锁，B线程完成所有业务需要5秒，当在第12秒的时候，A线程完活，B线程还在干活呢！A线程就释放了B线程加的锁，这样，就是把别人的锁给释放了，放B线程完活以后，发现，诶？？我的锁呢？？？这就出现了张冠李戴的现象 ###

@GetMapping(value = "/buy/{id}")
        public String buy(@PathVariable("id")Integer id){
            String value = UUID.randomUUID().toString()+Thread.currentThread().getName();
            try{
                //设置为同一行，为了保证原子性
                Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK,value,10L, TimeUnit.SECONDS); //setNX
    //            stringRedisTemplate.expire(REDIS_LOCK,10L,TimeUnit.SECONDS);
                System.out.println(flag);
                if(flag==null){
                    System.out.println("抢锁失败，请重试~~");
                    return "抢锁失败，请重试~~";
                }
    
                String result = stringRedisTemplate.opsForValue().get("goods");
                int goodsNumber = result == null ? 0 : Integer.parseInt(result);
                if(goodsNumber > 0){
                    int realNumber = goodsNumber - 1;
                    stringRedisTemplate.opsForValue().set("goods",String.valueOf(realNumber));
                    System.out.println("成功购买到商品，库存还剩下："+realNumber+"件"+"\t 服务提供端口"+serverPort);
    
    
                    return "成功购买商品，库存还剩下："+realNumber+" 件"+"\t 服务提供端口"+serverPort;
                }else{
                    System.out.println("商品已经售完/活动结束/调用超时，欢迎下次光临......."+"\t 服务提供端口"+serverPort);
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                stringRedisTemplate.delete(REDIS_LOCK);
            }
    
            return "nacos registry, serverPort: " + serverPort + "\t id" + id + "\n"
                    + "商品已经售完/活动结束/调用超时，欢迎下次光临.......";
    
        }

## ##

# 程序4.0版本，finally代码块要判断这把锁是不是自己的，如果不是自己锁就不许动，不许删除 #

在程序4.0的基础上，把finally代码块里面的代码改为

finally {
                //判断是不是自己的锁
                if(stringRedisTemplate.opsForValue().get(REDIS_LOCK).equalsIgnoreCase(value)){
                    stringRedisTemplate.delete(REDIS_LOCK);
                }
            }

### 然而，在分布式微服务架构中，多线程高并发的情况下，if判断和delete操作并不是原子性的，会出现 "判断过期" 的现象。假设 A线程执行到finally的if条件这行代码，发现确实是自己的ALock锁，然而，这时候A线程在纳秒级内在if里面卡住了，这时候锁恰好过期，自动释放了锁，B线程紧接着加了BLock锁，A线程却误解了BLock锁，还是会出现"张冠李戴"的现象。 ###

# 程序5.0版本，我们使用redis事务来解决这个"张冠李戴，误解锁"的问题 #

首先我们来了解redis事务

MULTI表示redis事务的开始，WATCH表示监听某个键的值是否发生变化，如果发现提交事务之前，这个键被别人改过了，提交事务就会返回空

一开始，我们在redis设置key1为value1

在第一个终端设置：

![20210307230108784.png][]

在第二个终端，直接去改变key1的值

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 2][]

再次回到第一个终端，去提交事务

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 3][]

发现key1的值还是value66666666，并没有被第一个终端改为value1111111

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 4][]

因为第一个终端监听key1的值，发现key1已经被别人改了，自己就不要去动了，如果没有被别人修改，就可以动。

所以，我们要把finally代码块改为

while(true){
                    stringRedisTemplate.watch(REDIS_LOCK);
                    if(stringRedisTemplate.opsForValue().get(REDIS_LOCK).equalsIgnoreCase(value)){
                        stringRedisTemplate.setEnableTransactionSupport(true);
                        stringRedisTemplate.multi();//开启事务
                        stringRedisTemplate.delete(REDIS_LOCK);
                        List<Object> list = stringRedisTemplate.exec();
                        System.out.println("打印list集合：：："+list.get(0));
                        /*如果list等于null了，说明数据被别人动过了，直接结束本趟循环，不执行stringRedisTemplate.unwatch();，
                        直接从头开始判断是不是这把锁是不是自己的，
                        最后发现肯定不是自己的，直接跳出while走人
                         */
                        if(list == null){
                            continue;
                        }
                    }
    
                    stringRedisTemplate.unwatch();
                    break;
                }

最终，我们的代码改成这个样子：

@GetMapping(value = "/payment/nacos/{id}")
        public String getPayment(@PathVariable("id")Integer id){
            String value = UUID.randomUUID().toString()+Thread.currentThread().getName();
            try{
                //设置为同一行，为了保证原子性
                Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK,value,10L,TimeUnit.SECONDS); //setNX
    //            stringRedisTemplate.expire(REDIS_LOCK,10L,TimeUnit.SECONDS);
                System.out.println(flag);
                if(flag==null){
                    System.out.println("抢锁失败，请重试~~");
                    return "抢锁失败，请重试~~";
                }
    
                String result = stringRedisTemplate.opsForValue().get("goods:001");
                int goodsNumber = result == null ? 0 : Integer.parseInt(result);
                if(goodsNumber > 0){
                    int realNumber = goodsNumber - 1;
                    stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realNumber));
                    System.out.println("成功购买到商品，库存还剩下："+realNumber+"件"+"\t 服务提供端口"+serverPort);
    
                    return "成功购买商品，库存还剩下："+realNumber+" 件"+"\t 服务提供端口"+serverPort;
                }else{
                    System.out.println("商品已经售完/活动结束/调用超时，欢迎下次光临......."+"\t 服务提供端口"+serverPort);
                }
    
                return "nacos registry, serverPort: " + serverPort + "\t id" + id + "\n"
                        + "商品已经售完/活动结束/调用超时，欢迎下次光临.......";
    
            }catch (Exception e){
                e.printStackTrace();
            }finally {
    //            //判断加锁与解锁是不是同一个客户端
    //            if(stringRedisTemplate.opsForValue().get(REDIS_LOCK).equalsIgnoreCase(value)){
    //                //若此时，A线程走进if里面去了，这把锁突然不是这个客户端的，即B线程进去先把这个代码执行了，则会误解锁
    //                stringRedisTemplate.delete(REDIS_LOCK);
    //            }
    //            stringRedisTemplate.delete(REDIS_LOCK);
                while(true){
                    stringRedisTemplate.watch(REDIS_LOCK);
                    if(stringRedisTemplate.opsForValue().get(REDIS_LOCK).equalsIgnoreCase(value)){
                        stringRedisTemplate.setEnableTransactionSupport(true);
                        stringRedisTemplate.multi();//开启事务
                        stringRedisTemplate.delete(REDIS_LOCK);
                        List<Object> list = stringRedisTemplate.exec();
                        System.out.println("打印list集合：：："+list.get(0));
                        /*如果list等于null了，说明数据被别人动过了，直接结束本趟循环，不执行stringRedisTemplate.unwatch();，
                        直接从头开始判断是不是这把锁是不是自己的，
                        最后发现肯定不是自己的，直接跳出while走人
                         */
                        if(list == null){
                            continue;
                        }
                    }
    
                    stringRedisTemplate.unwatch();
                    break;
                }
    
            }
            return "nacos registry, serverPort: " + serverPort + "\t id" + id + "\n"
                    + "商品已经售完/活动结束/调用超时，欢迎下次光临.......";
    
        }
    
    
    }

### 通过测试，并不会出现超卖的现象，但是，如果随着线程的增多，就会频繁出现 "抢票失败，请重试" 的现象。这大大地影响了用户体验 ###

### 在真实的生产环境下，我们会遇到一层一层的问题，解决了一个问题，下一个新的问题也会随之诞生 ###

# 程序6.0版，就直接用我们最喜欢的Reeission吧 #

@RestController
    public class BuyController {
        @Autowired
        StringRedisTemplate stringRedisTemplate;
    
        String REDIS_LOCK = "redisLock";
    
        @Value("${server.port}")
        private String serverPort;
    
        @Autowired
        Redisson redisson;
    
        @GetMapping(value = "/buy/{id}")
        public String buy(@PathVariable("id")Integer id){
            RLock redissionLock = redisson.getLock(REDIS_LOCK);
            try{
                redissionLock.lock();
    
                String result = stringRedisTemplate.opsForValue().get("goods:001");
                int goodsNumber = result == null ? 0 : Integer.parseInt(result);
                if(goodsNumber > 0){
                    int realNumber = goodsNumber - 1;
                    stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realNumber));
                    System.out.println("成功购买到商品，库存还剩下："+realNumber+"件"+"\t 服务提供端口"+serverPort);
    
                    return "成功购买商品，库存还剩下："+realNumber+" 件"+"\t 服务提供端口"+serverPort;
                }else{
                    System.out.println("商品已经售完/活动结束/调用超时，欢迎下次光临......."+"\t 服务提供端口"+serverPort);
                }
    
                return "nacos registry, serverPort: " + serverPort + "\t id" + id + "\n"
                        + "商品已经售完/活动结束/调用超时，欢迎下次光临.......";
    
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if(redissionLock.isLocked() && redissionLock.isHeldByCurrentThread()){
                    redissionLock.unlock();
                }
            }
            return "nacos registry, serverPort: " + serverPort + "\t id" + id + "\n"
                    + "商品已经售完/活动结束/调用超时，欢迎下次光临.......";
    
    
        }
    
    }

### 通过jmeter测试以后，不仅没有发现超卖的现象，而且还不会出现什么"抢锁失败"的现象 ###

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70]: /images/20221023/9cc646a9f3ec4041ac7bfb36983f1466.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 1]: /images/20221023/a88706af66524c3fb11717e9e6fb68ca.png
[20210307214945318.png]: /images/20221023/c89166ada2d94ec2893a3a2c70e07410.png
[20210307215036444.png]: /images/20221023/2e1cb0d8c2f040cba4d0a083662e3c52.png
[20210307215050368.png]: /images/20221023/a4791f38ab214a68bfa0a5ecc8cc5ad6.png
[20210307230108784.png]: /images/20221023/cac5d169f2f44783a75d3d07baec5cf0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 2]: /images/20221023/2095682af5be421a94857aefd4523a54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 3]: /images/20221023/9930e279014e49d9a0963d65314ac8d3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1hlb25fQ0M_size_16_color_FFFFFF_t_70 4]: /images/20221023/7fbc7cd4bf904be09bf14ae1b09940cc.png