[一个简单的秒杀架构的演变]1. 传统方式

地址

• Github：https://github.com/dolyw/SeckillEvolution
• Gitee(码云)：https://gitee.com/dolyw/SeckillEvolution

目录

• 0. 整体流程
• 1. 传统方式
• 2. 使用乐观锁
• 3. 使用缓存
• 4. 使用分布式限流
• 5. 使用队列异步下单

1. 思路介绍

不做任何控制，按照流程进行检查库存，扣库存，下订单，这种方式会存在并发问题

2. 代码实现

在SeckillEvolutionController创建一个传统方式下订单入口的方法

• SeckillEvolutionController

/**
 * 传统方式下订单
 * 
 * @param id 商品ID
 * @return com.example.common.ResponseBean
 * @throws Exception
 * @author wliduo[i@dolyw.com]
 * @date 2019/11/21 19:50
 */
@PostMapping("/createWrongOrder/{id}")
public ResponseBean createWrongOrder(@PathVariable("id") Integer id) throws Exception {
    Integer orderCount = seckillEvolutionService.createWrongOrder(id);
    return new ResponseBean(HttpStatus.OK.value(), "购买成功", orderCount);
}

在Service添加方法

• ISeckillEvolutionService

/**
 * 传统方式的创建订单(并发会出现错误)
 * 
 * @param id
 * @return java.lang.Integer
 * @throws Exception
 * @author wliduo[i@dolyw.com]
 * @date 2019/11/22 14:21
 */
Integer createWrongOrder(Integer id) throws Exception;

• ISeckillEvolutionService

/**
 * 传统方式(名称注入)
 */
@Autowired
@Qualifier("seckillTraditionService")
private ISeckillService seckillTraditionService;

@Override
@Transactional(rollbackFor = Exception.class)
public Integer createWrongOrder(Integer id)  throws Exception {
    // 检查库存
    StockDto stockDto = seckillTraditionService.checkStock(id);
    // 扣库存
    Integer saleCount = seckillTraditionService.saleStock(stockDto);
    if (saleCount <= 0) {
        throw new CustomException("扣库存失败");
    }
    // 下订单
    Integer orderCount = seckillTraditionService.createOrder(stockDto);
    if (saleCount <= 0) {
        throw new CustomException("下订单失败");
    }
    return orderCount;
}

然后创建一个ISeckillService的传统方式的实现类提供上面使用

• SeckillTraditionServiceImpl

package com.example.seckill.impl;

import ...

/**
 * 传统方式(并发会出现错误)
 *
 * @author wliduo[i@dolyw.com]
 * @date 2019-11-20 18:03:33
 */
@Service("seckillTraditionService")
public class SeckillTraditionServiceImpl implements ISeckillService {

    @Autowired
    private StockDao stockDao;

    @Autowired
    private StockOrderDao stockOrderDao;

    @Override
    public StockDto checkStock(Integer id) {
        StockDto stockDto = stockDao.selectByPrimaryKey(id);
        if (stockDto.getCount() > 0) {
            return stockDto;
        }
        throw new CustomException("库存不足");
    }

    @Override
    public Integer saleStock(StockDto stockDto) {
        stockDto.setCount(stockDto.getCount() - 1);
        stockDto.setSale(stockDto.getSale() + 1);
        return stockDao.updateByPrimaryKey(stockDto);
    }

    @Override
    public Integer createOrder(StockDto stockDto) {
        StockOrderDto stockOrderDto = new StockOrderDto();
        stockOrderDto.setStockId(stockDto.getId());
        return stockOrderDao.insertSelective(stockOrderDto);
    }
}

3. 开始测试

使用JMeter测试上面的代码，JMeter的使用可以查看: JMeter的安装使用

我们调用一下商品库存初始化的方法，我使用的是PostMan，初始化库存表商品10个库存，而且清空订单表

这时候可以看到我们的数据，库存为10，卖出为0，订单表为空

打开JMeter，添加测试计划(测试计划文件在项目的src\main\resources\jmx下)，模拟500个并发线程测试秒杀10个库存的商品，填写请求地址，点击启动图标开始

可以看到500个并发线程，抢购到了24个订单，而我们的商品实际显示为卖出10，库存还有0

这就是卖超问题了，这是因为同一时间大量线程同时请求校验库存，扣库存，创建订单，这三个操作不在同一个原子，比如，很多线程同时读到库存为10，这样都穿过了校验库存的判断，所以出现卖超问题

在这种情况下就引入了锁的概念，锁区分为乐观锁和悲观锁，悲观锁都是牺牲性能保证数据，所以在这种高并发场景下，一般都是使用乐观锁解决