乐观锁+Redis缓存实现商品下单减库存【SpringCloud系列17】

阳光穿透心脏的1/2处 2023-10-09 17:33 12阅读 0赞

> SpringCloud 大型系列课程正在制作中，欢迎大家关注与提意见。

本文章是系列文章中的一篇

*  [1、SpringCloud 项目基础工程搭建 【SpringCloud系列1】][1_SpringCloud _ _SpringCloud_1]
 *  [2、SpringCloud 集成Nacos注册中心 【SpringCloud系列2】][2_SpringCloud _Nacos_ _SpringCloud_2]
 *  [3、SpringCloud Feign远程调用 【SpringCloud系列3】][3_SpringCloud Feign_ _SpringCloud_3]
 *  [4、SpringCloud Feign远程调用公共类抽取 【SpringCloud系列4】][4_SpringCloud Feign_ _SpringCloud_4]
 *  [5、SpringCloud 整合Gateway服务网关 【SpringCloud系列5】][5_SpringCloud _Gateway_ _SpringCloud_5]
 *  [6、SpringCloud 整合 Spring Security 认证鉴权【SpringCloud系列6】][6_SpringCloud _ Spring Security _SpringCloud_6]
 *  [SpringCloud网关Gateway认证鉴权【SpringCloud系列7】][SpringCloud_Gateway_SpringCloud_7]
 *  [SpringCloud Gateway 通过redis实现限流【SpringCloud系列8】][SpringCloud Gateway _redis_SpringCloud_8]
 *  [SpringCloud Gateway 整合阿里 Sentinel网关流控、熔断、降级【SpringCloud系列9】][SpringCloud Gateway _ Sentinel_SpringCloud_9]
 *  [SpringCloud Gateway 整合RSA对请求参数解密、响应结果加密【SpringCloud系列10】][SpringCloud Gateway _RSA_SpringCloud_10]
 *  [SpringCloud 业务管理后台 通过FeignClient来调用oauth/token接口【SpringCloud系列11】][SpringCloud _ _FeignClient_oauth_token_SpringCloud_11]
 *  [Spring Security OAuth2.0 多点登录与单点登录【SpringCloud系列12】][Spring Security OAuth2.0 _SpringCloud_12]
 *  [SpringCloud 微信小程序登录 方案一【SpringCloud系列13】][SpringCloud _ _SpringCloud_13]
 *  [SpringCloud 微信小程序 获取手机号一键登录 【SpringCloud系列14】][SpringCloud _ _ _SpringCloud_14]
 *  [SpringCloud 微信小程序 获取用户信息一键登录 【SpringCloud系列15】][SpringCloud _ _ _SpringCloud_15]
 *  [SpringCloud 网关实现线程池异步批量保存请求日志 【SpringCloud系列16】][SpringCloud _ _SpringCloud_16]

##### 1 下单减库存 V1 无锁 #####

并发情况下，库存一塌糊涂

/**
         * 创建订单
         *
         * @param goodsId 商品ID
         * @param userId  用户ID
         * @return
         * @throws Exception
         */
        @Override
        @Transactional
        public OrderInfo createWrongOrder(Long goodsId, Long userId) throws Exception {
        
    
            OrderInfo orderInfo = null;
            // 数据库校验库存
            GoodsInfo goodsInfo = checkStock(goodsId);
            // 扣库存(无锁)
            boolean b = saleStock(goodsInfo);
            if (!b) {
        
                throw new RuntimeException("库存不足 减库存失败");
            }
            log.info("扣库存完成");
            // 生成订单
            orderInfo = createOrder(goodsInfo, userId);
            log.info("下单完成");
            
            return orderInfo;
        }
    
        private GoodsInfo checkStock(Long sid) throws Exception {
        
            //查询商品详情
            GoodsInfo goodsInfo = goodsInfoService.getGoodsInfoById(sid);
            log.info("当前库存 {}", goodsInfo.getGoodsStock());
            if (goodsInfo.getGoodsStock() < 1) {
        
                throw new RuntimeException("库存不足");
            }
            return goodsInfo;
        }
    
        /**
         * 更新库存
         *
         * @param goodsInfo
         * @return
         */
        private boolean saleStock(GoodsInfo goodsInfo) {
        
            goodsInfo.setGoodsSale(goodsInfo.getGoodsSale() + 1);
            goodsInfo.setGoodsStock(goodsInfo.getGoodsStock() - 1);
            return goodsInfoService.updateStockById(goodsInfo);
        }

10个商品库存，1秒100个并发下单测试，结果是库存正常减为0，订单创建了88个，严重超卖。  
![在这里插入图片描述][5813c33114fd470092249d12697aaa8d.png]

如下图是JMeter压测  
![在这里插入图片描述][9311d2e6e6314c6c94ffdfa5ca984cae.png]  
其中更新库存的实现如下

@Mapper
    public interface GoodsInfoMapper extends BaseMapper<GoodsInfo> {
        
        // 扣库存 Mapper 文件
        @Update("UPDATE tb_goods SET goods_stock = #{goodsStock, jdbcType = INTEGER},  goods_sale = #{goodsSale,jdbcType = INTEGER} WHERE id = #{id, jdbcType = INTEGER}")
        boolean updateStockById(GoodsInfo goodsInfo);
    }

###### 1.1 synchronized(同步锁) 悲观锁 ######

@Override
        @Transactional
        public synchronized OrderInfo createWrongOrder(Long goodsId, Long userId) throws Exception {
        
    
            OrderInfo orderInfo = null;
            // 数据库校验库存
            GoodsInfo goodsInfo = checkStock(goodsId);
            // 扣库存(无锁)
            boolean b = saleStock(goodsInfo);
            if (!b) {
        
                throw new RuntimeException("库存不足 减库存失败");
            }
            log.info("扣库存完成");
            // 生成订单
            orderInfo = createOrder(goodsInfo, userId);
            log.info("下单完成");
    
            return orderInfo;
        }

10个商品库存，1秒100个并发下单测试，结果是库存正常减为0，订单创建了13个，出现超卖。

###### 1.2 MySql 乐观锁实现 ######

直接在减库存的时候来判断

@Mapper
    public interface GoodsInfoMapper extends BaseMapper<GoodsInfo> {
        
        // 扣库存 Mapper 文件
        @Update("UPDATE tb_goods SET goods_stock =goods_stock-1,goods_sale=goods_sale+1, version = version+1 WHERE id = #{id, jdbcType = INTEGER} AND version = #{version, jdbcType = INTEGER}")
        boolean updateStockById(GoodsInfo goodsInfo);
    }

每执行一次更新，version就会+1，库存更新成功后，才会继续创建订单。  
![在这里插入图片描述][435e2539517e47a09a8bc5695f9c25cc.png]  
压测如下：  
10个商品库存，1秒100个并发下单测试，结果是库存正常减为0，订单创建了10个，正常，中间并发的请求会下单失败，  
![在这里插入图片描述][6cf2476a189d46359de12dbdd02747fd.png]  
启动订单服务两个负载来压测，也可以正常下单，正常减库存  
![在这里插入图片描述][61bf7f4bc99146a189d38d772e404a2e.png]

##### 2. Redis 计数限流 #####

在上述的压力测试中，1个商品10 个库存，有 1000 个并发秒杀请求，最终只有 10 个订单会成功创建，也就是说有 990 的请求是无效的，这些无效的请求也会给数据库带来压力，因此可以在在请求落到数据库之前就将无效的请求过滤掉，将并发控制在一个可控的范围，这样落到数据库的压力就小很多。

所以对下单接口可以出现的大量请求常常是在秒杀场景中，所以可以针对这个接口进行一下限流：

*  [阿里 Sentinel网关流控、熔断、降级][SpringCloud Gateway _ Sentinel_SpringCloud_9]
 *  [Gateway 通过redis实现限流][Gateway _redis]

对于每个没有被过滤掉的请求，都会去数据库查询库存来判断库存是否充足，对于这个查询可以放在缓存 Redis 中，Redis 的数据是存放在内存中的，速度快很多。

对于普通商品来说，在创建商品以及修改商品时，就可以将商品信息以及库存同步到Redis中。

对于秒杀商品来说，在秒杀前几分钟，通过定时任务将秒杀商品以及库存同步到Redis中。

##### 3 乐观锁+Redis 实现下单减库存 #####

缓存和数据一致性 ，缓存和 数据库（DB） 的一致性是一个讨论很多的问题

###### 3.1 先更新数据库，再更新缓存策略 ######

假设 A、B 两个线程，A 成功更新数据，在要更新缓存时，A 的时间片用完了，B 更新了数据库接着更新了缓存，这是 CPU 再分配给 A，则 A 又更新了缓存，这种情况下缓存中就是脏数据，具体逻辑如下图所示：  
![在这里插入图片描述][cb00ae354195479da57dcca5e4605a17.png]  
解决方法就是：缓存不做更新，仅做删除，先更新数据库再删除缓存。  
A 更新了数据库，还没来得及删除缓存，B 又更新了数据库，接着删除了缓存，然后 A 删除了缓存，这样只有下次缓存未命中时，才会从数据库中重建缓存，避免了脏数据。

这种方式，由于每次都删除缓存，因此导致多次缓存都不能命中，能命中缓存的次数很少，因此删除这种方案并不可取，效率也并不是很高。

实际可以使用的是 先更新数据库再更新缓存，更新数据库使用乐观锁，更新Redis缓存结合Redis事务。

###### 2 商品信息添加到 Redis 中 ######

我这里是测试使用，所以专门写了一个接口来将商品信息以及库存信息加载到Redis中，常量Key定义如下：

public class Constant {
        
        public static final String GOOOD_STOCK = "STOCK_COUNT:";//库存
        public static final String GOOOD_SALE= "STOCK_SALE:";//销量
        public static final String GOOOD_VERSION = "STOCK_VERSION:";//版本
        public static final String GOODS_NAME = "GOODS_NAME:";//商品名称
        public static final String GOODS_INFO ="GOODS_INFO:";//商品
    }

接下来就是商品信息对应的数据库的数据的基本操作，大家可以查看文章底部的源码。

*  GoodsInfo 是商品信息
 *  GoodsInfoMapper 是商品信息操作Mapper

@Service
    @Slf4j
    public class GoodsInfoServiceImple extends ServiceImpl<GoodsInfoMapper, GoodsInfo> implements GoodsInfoService {
        
    
        @Resource
        GoodsInfoMapper goodsInfoMapper;
        @Resource
        RedisService redisService;
    
        /**
         * 测试使用将商品数据加载到redis中
         *
         * @param sid
         */
        @Override
        public void testRedisLoadGoods(Long sid) {
        
            GoodsInfo goodsInfo = this.getById(sid);
            if (goodsInfo == null) {
        
                return;
            }
            Long goodsId = goodsInfo.getId();
            redisService.set(Constant.GOOOD_STOCK + goodsId, goodsInfo.getGoodsStock());
            redisService.set(Constant.GOOOD_SALE + goodsId, goodsInfo.getGoodsSale());
            redisService.set(Constant.GOOOD_VERSION + goodsId, goodsInfo.getVersion());
            redisService.set(Constant.GOODS_NAME + goodsId, goodsInfo.getGoodsName());
            redisService.set(Constant.GOODS_INFO + goodsId, goodsInfo);
        }
    
    }

保存在Redis中的数据如下（这里使用的RDM工具连接的Redis服务）

![在这里插入图片描述][c6e04b3beeff47e3b00e904253981a8e.png]

然后就是实现下单的逻辑

*  第一步 校验库存，从 Redis 中获取
 *  第二步 乐观锁更新 MySql 库存
 *  第三步 Redis事务更新Redis缓存
 *  第四步 创建订单

@Service
    @Slf4j
    public class OrderServiceImpl extends ServiceImpl<OrderMapper, OrderInfo> implements OrderService {
        
    
        @Autowired
        SnowFlakeCompone snowFlakeCompone;
    
        /**
         * redis 分布式事务
         */
        @Resource
        RedisService redisService;
    
        /**
         * 乐观锁更新库存和Redis
         * @param goodsId 商品ID
         * @param userId 用户ID
         * @return
         * @throws Exception
         */
        @Override
        public OrderInfo createOrderWithLimitAndRedis(Long goodsId, Long userId) throws Exception {
        
            // 校验库存，从 Redis 中获取
            GoodsInfo goodsInfo = checkStockWithRedis(goodsId);
            // 乐观锁更新库存和Redis
            saleStockOptimsticWithRedis(goodsInfo);
            // 创建订单
            OrderInfo res = createOrder(goodsInfo, userId);
            return res;
        }
    
        // Redis 中校验库存
        private GoodsInfo checkStockWithRedis(Long goodsId) throws Exception {
        
            int count = Integer.parseInt(redisService.get(Constant.GOOOD_STOCK + goodsId).toString());
            int sale = Integer.parseInt(redisService.get(Constant.GOOOD_SALE + goodsId).toString());
            int version = Integer.parseInt(redisService.get(Constant.GOOOD_VERSION + goodsId).toString());
            String goodsName = redisService.get(Constant.GOODS_NAME + goodsId).toString();
            if (count < 1) {
        
                log.info("库存不足");
                throw new RuntimeException("库存不足 Redis currentCount: " + sale);
            }
            GoodsInfo stock = new GoodsInfo();
            stock.setId(goodsId);
            stock.setGoodsStock(count);
            stock.setGoodsSale(sale);
            stock.setVersion(version);
            stock.setGoodsName(goodsName);
    
            return stock;
        }
    
    
        // 更新 DB 和 Redis
        private void saleStockOptimsticWithRedis(GoodsInfo goodsInfo) throws Exception {
        
            boolean res = goodsInfoService.updateStockByOptimistic(goodsInfo);
            if (!res) {
        
                throw new RuntimeException("并发更新库存失败");
            }
            // 更新 Redis
            redisService.updateStockWithRedis(goodsInfo);
        }
    
    }

Jemter 测试，1秒2000个并发，订单服务两个负载：  
![在这里插入图片描述][be73cc1a1dd14693b2a4df3063b19ec3.png]  
![在这里插入图片描述][b576931a28c44167adbc4ac0e02e6f97.png]  
18秒处理完这2000个请求，对于用户量小、普通下单来讲的开发这样是可以的，秒杀也可以，只不过是在此基础上添加上限流、Redis校验用户是否秒杀过就可以。

商品乐观锁更新库存的核心代码如下：

@Mapper
    public interface GoodsInfoMapper extends BaseMapper<GoodsInfo> {
        
    
        //乐观锁更新数据库
        @Update("UPDATE tb_goods SET goods_stock =goods_stock-1,goods_sale=goods_sale+1, version = version+1 WHERE id = #{id, jdbcType = INTEGER} AND version = #{version, jdbcType = INTEGER}")
        boolean updateStockByOptimistic(GoodsInfo goodsInfo);
    }

分布式锁更新Redis缓存核心代码如下：

/**
     * Redis操作Service实现类
     */
    @Service
    @Slf4j
    public class RedisServiceImpl implements RedisService {
        
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        ...其他方法
        
        //Redis - Jedis连接池
        @Autowired
        private JedisPool jedisPool;
        @Override
        public void updateStockWithRedis(GoodsInfo goodsInfo) {
        
            // Redis 多个写入操作的事务
            Jedis jedis = null;
            try {
        
                jedis = jedisPool.getResource();
                // 开始事务
                Transaction transaction = jedis.multi();
                // 事务操作
                this.decr(Constant.GOOOD_STOCK+ goodsInfo.getId(),1);
                this.incr(Constant.GOOOD_SALE + goodsInfo.getId(),1);
                this.incr(Constant.GOOOD_VERSION+ goodsInfo.getId(),1);
                // 结束事务
                List<Object> list = transaction.exec();
            } catch (Exception e) {
        
                log.error("updateStock 获取 Jedis 实例失败：", e);
            } finally {
        
                if (jedis != null) {
        
                    jedis.close();
                }
    
            }
        }
    }

最后就是源码了：  
本项目 SpringCloud 源码 [https://gitee.com/android.long/spring-cloud-biglead/tree/master/biglead-api-11-admin][https_gitee.com_android.long_spring-cloud-biglead_tree_master_biglead-api-11-admin]  
本项目 管理后台web 源码[https://gitee.com/android.long/spring-cloud-biglead/tree/master/mall-admin-web-master][https_gitee.com_android.long_spring-cloud-biglead_tree_master_mall-admin-web-master]  
本项目 小程序 源码[https://gitee.com/android.long/spring-cloud-biglead/tree/master/mall-app-web-master][https_gitee.com_android.long_spring-cloud-biglead_tree_master_mall-app-web-master]  
如果有兴趣可以关注一下公众号 biglead ,每周都会有 java、Flutter、小程序、js 、英语相关的内容分享

[1_SpringCloud _ _SpringCloud_1]: https://biglead.blog.csdn.net/article/details/129668121
[2_SpringCloud _Nacos_ _SpringCloud_2]: https://biglead.blog.csdn.net/article/details/129672545
[3_SpringCloud Feign_ _SpringCloud_3]: https://biglead.blog.csdn.net/article/details/129674404
[4_SpringCloud Feign_ _SpringCloud_4]: https://blog.csdn.net/zl18603543572/article/details/129675612
[5_SpringCloud _Gateway_ _SpringCloud_5]: https://biglead.blog.csdn.net/article/details/129678919
[6_SpringCloud _ Spring Security _SpringCloud_6]: https://biglead.blog.csdn.net/article/details/129687071
[SpringCloud_Gateway_SpringCloud_7]: https://blog.csdn.net/zl18603543572/article/details/129699896
[SpringCloud Gateway _redis_SpringCloud_8]: https://blog.csdn.net/zl18603543572/article/details/129707395
[SpringCloud Gateway _ Sentinel_SpringCloud_9]: https://biglead.blog.csdn.net/article/details/129710023
[SpringCloud Gateway _RSA_SpringCloud_10]: https://blog.csdn.net/zl18603543572/article/details/129726501
[SpringCloud _ _FeignClient_oauth_token_SpringCloud_11]: https://biglead.blog.csdn.net/article/details/129772853
[Spring Security OAuth2.0 _SpringCloud_12]: https://biglead.blog.csdn.net/article/details/129783953
[SpringCloud _ _SpringCloud_13]: https://blog.csdn.net/zl18603543572/article/details/129864600
[SpringCloud _ _ _SpringCloud_14]: https://biglead.blog.csdn.net/article/details/129874998
[SpringCloud _ _ _SpringCloud_15]: https://blog.csdn.net/zl18603543572/article/details/129877821
[SpringCloud _ _SpringCloud_16]: https://biglead.blog.csdn.net/article/details/130113744
[5813c33114fd470092249d12697aaa8d.png]: https://img-blog.csdnimg.cn/5813c33114fd470092249d12697aaa8d.png
[9311d2e6e6314c6c94ffdfa5ca984cae.png]: https://img-blog.csdnimg.cn/9311d2e6e6314c6c94ffdfa5ca984cae.png
[435e2539517e47a09a8bc5695f9c25cc.png]: https://img-blog.csdnimg.cn/435e2539517e47a09a8bc5695f9c25cc.png
[6cf2476a189d46359de12dbdd02747fd.png]: https://img-blog.csdnimg.cn/6cf2476a189d46359de12dbdd02747fd.png
[61bf7f4bc99146a189d38d772e404a2e.png]: https://img-blog.csdnimg.cn/61bf7f4bc99146a189d38d772e404a2e.png
[Gateway _redis]: https://biglead.blog.csdn.net/article/details/129707395
[cb00ae354195479da57dcca5e4605a17.png]: https://img-blog.csdnimg.cn/cb00ae354195479da57dcca5e4605a17.png
[c6e04b3beeff47e3b00e904253981a8e.png]: https://img-blog.csdnimg.cn/c6e04b3beeff47e3b00e904253981a8e.png
[be73cc1a1dd14693b2a4df3063b19ec3.png]: https://img-blog.csdnimg.cn/be73cc1a1dd14693b2a4df3063b19ec3.png
[b576931a28c44167adbc4ac0e02e6f97.png]: https://img-blog.csdnimg.cn/b576931a28c44167adbc4ac0e02e6f97.png
[https_gitee.com_android.long_spring-cloud-biglead_tree_master_biglead-api-11-admin]: https://gitee.com/android.long/spring-cloud-biglead/tree/master/biglead-api-11-admin
[https_gitee.com_android.long_spring-cloud-biglead_tree_master_mall-admin-web-master]: https://gitee.com/android.long/spring-cloud-biglead/tree/master/mall-admin-web-master
[https_gitee.com_android.long_spring-cloud-biglead_tree_master_mall-app-web-master]: https://gitee.com/android.long/spring-cloud-biglead/tree/master/mall-app-web-master