Springboot实现高并发秒杀系统

Springboot实现高并发秒杀系统 java高并发springbootrediszookeeper

杨家八公子

3553人浏览 · 2021-12-27 13:39:24

杨家八公子 · 2021-12-27 13:39:24 发布

背景

商品的库存为200个
实验目的： 200个商品只能生成200个订单抵抗高并发高流量
如果最终实验结果跟理论值不一致则视为bug
一致的话我们再逐步去优化，让系统可以抵挡高并发，系统的吞吐量有明显的提升

首先我们不加锁不加缓存不加事务

    @PostMapping("/{productId}")
    public AjaxResult seckill(@PathVariable("productId") Integer productId){

        try{
          orderService.Seckill(productId);
        }catch (Exception e){
            log.error("创建订单失败"+e);
            return AjaxResult.error("创建订单失败");
        }
        return AjaxResult.success();
    }

 public void Seckill(Integer productId){

        Product product = productService.getProductById(productId);
        if(product.getStock()<=0){
            throw new RuntimeException("商品库存已售完");
        }

        Order order = new Order();
        order.setProductId(productId);
        order.setAmount(product.getPrice());
        int i = orderMapper.insertSelective(order);

        //减库存
        int updateNum = productService.deductProductStock(productId);
        log.info("我是更新后的库存"+updateNum+"==============================");
        if(updateNum<=0){
            throw new RuntimeException("商品库存已售罄111");
        }

    }

在这里插入图片描述
我们可以看到运行完系统的吞吐量是

商品的库存也变为0

然而订单表却生成了300多个订单超卖了

很明显这不符合最终的效果而且还是很大的一个bug（致命性的）现在我们加上事务

  @Transactional
    public void Seckill(Integer productId){

        Product product = productService.getProductById(productId);
        if(product.getStock()<=0){
            throw new RuntimeException("商品库存已售完");
        }

        Order order = new Order();
        order.setProductId(productId);
        order.setAmount(product.getPrice());
        int i = orderMapper.insertSelective(order);

        //减库存
        int updateNum = productService.deductProductStock(productId);
        log.info("我是更新后的库存"+updateNum+"==============================");
        if(updateNum<=0){
            throw new RuntimeException("商品库存已售罄111");
        }

    }

加上事务之后我们可以看到吞吐量明显下降为300多
在这里插入图片描述

我们在来看订单表 200个订单没有超卖这实现了理论上的效果但是300多的吞吐量是不能抵挡高并发的
我们继续来优化
现在我们加上锁

   @PostMapping("/{productId}")
    public AjaxResult seckill(@PathVariable("productId") Integer productId){
        if(productSoldOutMap.get(productId) != null){
            log.error("商品已售罄");
            return AjaxResult.error("商品已售完");
        }
        Long stock = stringRedisTemplate.opsForValue().decrement(Constants.REDIS_PRODUCT_STOCK_PREFIX + productId);
        if(stock<0){
            productSoldOutMap.put(productId,true);
            Long increment = stringRedisTemplate.opsForValue().increment(Constants.REDIS_PRODUCT_STOCK_PREFIX + productId);
            log.info("=======================stock"+increment);
            return AjaxResult.error("商品已售完");
        }
        try{
          orderService.Seckill(productId);
        }catch (Exception e){
            创建订单少卖 还原库存
            stringRedisTemplate.opsForValue().increment(Constants.REDIS_PRODUCT_STOCK_PREFIX + productId);
            //修改标识
            if(productSoldOutMap.get(productId) != null){
                productSoldOutMap.remove(productId);
            }
            log.error("创建订单失败"+e);
            return AjaxResult.error("创建订单失败");
        }
        return AjaxResult.success();

    }

我们现在来看看吞吐量达到了4000多
在这里插入图片描述

我们再看看生成的订单
在这里插入图片描述
生成了200个订单是没有问题的

接下来我们配上负载均衡2台
在这里插入图片描述

发现吞吐量不是提升不是很明显

因为用了ConcurrentHashMap来存放是否售完的标记所以需要使用ZooKeeper在分布式环境中同步变量
上ZooKeeper

   @PostMapping("/{productId}")
    public AjaxResult seckill(@PathVariable("productId") Integer productId) throws InterruptedException, KeeperException {
        if(productSoldOutMap.get(productId) != null){
            log.error("商品已售罄");
            return AjaxResult.error("商品已售完");
        }
        Long stock = stringRedisTemplate.opsForValue().decrement(Constants.REDIS_PRODUCT_STOCK_PREFIX + productId);
        String zkSoldOutProductPath = Constants.getZKSoldOutProductPath(productId);
        if(stock<0){
            productSoldOutMap.put(productId,true);
            log.error("=====================商品售{}完标记",productId);
            Long increment = stringRedisTemplate.opsForValue().increment(Constants.REDIS_PRODUCT_STOCK_PREFIX + productId);
            log.info("=======================stock"+increment);
            if(zooKeeper.exists(zkSoldOutProductPath,true)==null){
                zooKeeper.create(zkSoldOutProductPath,"true".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
            }
            //监听zk售完标记节点
            zooKeeper.exists(zkSoldOutProductPath,true);
            return AjaxResult.error("商品已售完");
        }
        try{
          orderService.Seckill(productId);
        }catch (Exception e){
//            创建订单少卖 还原库存
            stringRedisTemplate.opsForValue().increment(Constants.REDIS_PRODUCT_STOCK_PREFIX + productId);
            //修改标识
            if(productSoldOutMap.get(productId) != null){
                productSoldOutMap.remove(productId);
            }
            if(zooKeeper.exists(zkSoldOutProductPath,true)!=null){
                zooKeeper.setData(Constants.getZKSoldOutProductPath(productId),"false".getBytes(),-1);
            }
            log.error("创建订单失败"+e);
            return AjaxResult.error("创建订单失败");
        }
        return AjaxResult.success();

    }

@Configuration
@Slf4j
public class ZooKeeperWatcher implements Watcher, ApplicationContextAware {

    private static ApplicationContext applicationContext;
    private ZooKeeper zooKeeper;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ZooKeeperWatcher.applicationContext =  applicationContext;
    }
    @Override
    public void process(WatchedEvent event) {
            if (Event.EventType.None == event.getType() && null == event.getPath()) {
                log.info("=====================zookeeper连接成功");
                if(zooKeeper==null){
                    zooKeeper = applicationContext.getBean(ZooKeeper.class);
                }
                try{
                    if(zooKeeper.exists(Constants.ZK_PRODUCT_SOLD_OUT_FLAG,false)==null){
                        zooKeeper.create(Constants.ZK_PRODUCT_SOLD_OUT_FLAG,"".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
                    }

                }catch (Exception e){
                    e.printStackTrace();
                }
            } else if (event.getType() == Event.EventType.NodeDataChanged) {  //zk目录节点数据变化通知事件
                try {
                   String path = event.getPath();
                   String soldOutFlag = new String(zooKeeper.getData(path,true,new Stat()));
                   log.info("zookeeper数据节点修改变动，path={},value={}",path,soldOutFlag);
                   if("false".equals(soldOutFlag)){
                       String productId = path.substring(path.lastIndexOf("/")+1,path.length());
                       OrderController.getProductsoldOutMap().remove(productId);
                   }
                } catch (Exception e) {
                    log.error("zookeeper数据节点修改回调事件异常");
                }
            }
    }
}

在这里插入图片描述

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...