单机环境下的秒杀问题

秒杀下单功能及并发测试

完整代码GitHub：https://github.com/xbhog/hm-dianping/tree/20230130-xbhog-redisSpike

秒杀条件分析：

• 秒杀是否开始或结束，如果尚未开始或已经结束则无法下单
• 库存是否充足，不足则无法下单

业务流程图：

开发流程：

优惠卷订单服务处理流程

1. 查询优惠卷

2. 判断用户是否在秒杀时间段内

3. 判断是否库存充足

4. 1. 不足：返回异常信息
   2. 充足：执行步骤4

5. 创建优惠卷订单

6. 落库

7. 返回订单ID

流程比较简单，这里需要注意的点是在库存扣减这部分

@Override
public Result seckillVoucher(Long voucherId) {// 1.查询优惠券// 2.判断秒杀是否开始// 3.判断秒杀是否已经结束// 4.判断库存是否充足if (voucher.getStock() < 1) {// 库存不足return Result.fail("库存不足！");}//5，扣减库//update tb_seckill_voucher set stock=stock -1  where voucher_id =  #{voucherId}boolean success  = seckillVoucherMapper.updateDateByVoucherId(voucherId);if (!success) {//扣减库存return Result.fail("库存不足！");}//6.创建订单// 6.1.全局唯一ID生成：订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);// 6.2.用户idLong userId = UserHolder.getUser().getId();voucherOrder.setUserId(userId);// 6.3.代金券idvoucherOrder.setVoucherId(voucherId);save(voucherOrder);return Result.ok(orderId);
}

jmeter进行测试：

条件：线程200，循环一次，查看汇总报告可以看出：

预期结果应该为异常是50%，但是这里显示为0%，查看数据库可以看出生成订单200个，库存为-100；

原因分析：

假设线程1过来查询库存，判断出来库存大于1，正准备去扣减库存，但是还没有来得及去扣减，此时线程2过来，线程2也去查询库存，发现这个数量一定也大于1，那么这两个线程都会去扣减库存，最终多个线程相当于一起去扣减库存，由此就会出现库存的超卖问题。

锁解决超卖问题

完整代码GitHub：https://github.com/xbhog/hm-dianping/tree/20230130-xbhog-redisSpike

解决方式

1. 悲观锁：可以实现对于数据的串行化执行，比如syn，和lock都是悲观锁的代表，同时，悲观锁中又可以再细分为公平锁，非公平锁，可重入锁，等等
2. 乐观锁：会有一个版本号，每次操作数据会对版本号+1，再提交回数据时，会去校验是否比之前的版本大1 ，如果大1 ，则进行操作成功，这套机制的核心逻辑在于，如果在操作过程中，版本号只比原来大1 ，那么就意味着操作过程中没有人对他进行过修改，他的操作就是安全的，如果不大1，则数据被修改过，当然乐观锁还有一些变种的处理方式比如cas

采用乐观锁解决超卖问题：

在操作时，对版本号进行+1 操作，然后要求version 如果是1 的情况下，才能操作，那么第一个线程在操作后，数据库中的version变成了2，但是他自己满足version=1 ，所以没有问题，此时线程2执行，线程2 最后也需要加上条件version =1 ，但是现在由于线程1已经操作过了，所以线程2，操作时就不满足version=1 的条件了，所以线程2无法执行成功。

修改上述代码有两种修改方式：

1. 只要我扣减库存时的库存和之前我查询到的库存是一样的，就意味着没有人在中间修改过库存，那么此时就是安全的。
2. 判断条件为库存数stock>0即可（解决问题）

测试第一种方式：100线程并发；数据库订单数为1，库存99(预期时库存0)。

通过测试发现会有99%失败的情况，跟我们预计的0%失败率来说相差很远，失败的原因在于：在使用乐观锁过程中假设100个线程同时都拿到了100的库存，然后大家一起去进行扣减，但是100个人中只有1个人能扣减成功，其他的人在处理时，他们在扣减时，库存已经被修改过了，所以此时其他线程都会失败。

解决方式就是修改库存数条件为stock>0

一人一单秒杀并发问题

完整代码GitHub：https://github.com/xbhog/hm-dianping/tree/20230130-xbhog-redisSpike

上述秒杀订单有一个问题，一个用户可以秒杀多次；优惠卷是为了引流，但是目前的情况是，一个人可以无限制的抢这个优惠卷，所以我们应当增加一层逻辑，让一个用户只能下一个单，而不是让一个用户下多个单。

相关流程图如下：

在原来的代码上增加用户判断：

// 5.一人一单逻辑
// 5.1.用户id
Long userId = UserHolder.getUser().getId();
int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
// 5.2.判断是否存在
if (count > 0) {// 用户已经购买过了return Result.fail("用户已经购买过一次！");
}

存在问题：现在的问题还是和之前一样，并发过来，查询数据库，都不存在订单，所以我们还是需要加锁，但是乐观锁比较适合更新数据，而现在是插入数据，所以我们需要使用悲观锁操作

当前注意点：

1. 线程安全实现
2. 锁的范围(颗粒度)
3. 事务问题

处理线程安全问题，将对数据库更新和插入的操作单独作为一个方法进行封装：

@Transactional
public synchronized Result createVoucherOrder(Long voucherId) {Long userId = UserHolder.getUser().getId();// 5.1.查询订单int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();// 5.2.判断是否存在if (count > 0) {// 用户已经购买过了return Result.fail("用户已经购买过一次！");}// 6.扣减库存//开始扣减库存(通过乐观锁--->对应数据库中行锁实现)boolean success  = seckillVoucherMapper.updateDateByVoucherId(voucherId);if (!success) {// 扣减失败return Result.fail("库存不足！");}// 7.创建订单VoucherOrder voucherOrder = new VoucherOrder();// 7.1.订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);// 7.2.用户idvoucherOrder.setUserId(userId);// 7.3.代金券idvoucherOrder.setVoucherId(voucherId);save(voucherOrder);// 7.返回订单idreturn Result.ok(orderId);
}

当前操作虽然可以解决线程安全，但是效率太低，每个进来的线程都要锁一下，这里我们可以尝试以用户ID来作为锁条件,但是使用userId.toString(),是重新new了一个对象，这就造成每个线程进来都不一样，锁不住。

public static String toString(long i) {if (i == Long.MIN_VALUE)return "-9223372036854775808";int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);char[] buf = new char[size];getChars(i, size, buf);return new String(buf, true);
}

这里我们使用userId.toString().intern()从常量池中查找数据。解决锁对象不一致的问题。

Long userId = UserHolder.getUser().getId();
synchronized(userId.toString().intern()){.......
}
@Transactional
public Result createVoucherOrder(Long voucherId) {Long userId = UserHolder.getUser().getId();synchronized(userId.toString().intern()){log.info("开始进行用户秒杀活动：{}",userId);//一人一单逻辑Integer count = voucherOrderService.query().eq("voucher_id", voucherId).eq("user_id", userId).count();if(count > 0){return Result.fail("该用户已参加活动。");}//开始扣减库存(通过乐观锁--->对应数据库中行锁实现)boolean success  = seckillVoucherMapper.updateDateByVoucherId(voucherId);if(!success){return Result.fail("库存不足，正在补充!");}//创建订单VoucherOrder voucherOrder = new VoucherOrder();long orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);voucherOrder.setUserId(userId);voucherOrder.setVoucherId(voucherId);voucherOrderService.save(voucherOrder);return Result.ok(orderId);}
//这里事务还没有提交事务，但是锁已经释放了。
}

但是! 以上代码还是存在问题；

问题的原因在于当前方法被spring的事务控制，如果你在方法内部加锁，可能会导致当前方法事务还没有提交，但是锁已经释放也会导致问题.

解决：把用户ID放入外部.将当前方法整体包裹起来，确保事务不会出现问题

@Slf4j
@Service
public class VoucherOrderServiceImpl extends ServiceImpl implements IVoucherOrderService {@Resourceprivate ISeckillVoucherService seckillVoucherService;@Resourceprivate SeckillVoucherMapper seckillVoucherMapper;@Resourceprivate IVoucherOrderService voucherOrderService;@Resourceprivate RedisIdWorker redisIdWorker;@Overridepublic Result seckillVoucher(Long voucherId) {//查询优惠卷库存信息SeckillVoucher voucher = seckillVoucherService.getById(voucherId);log.info("查询秒杀优惠卷：{}",voucher);//判断秒杀是否开始：开始时间，结束时间if(voucher.getBeginTime().isAfter(LocalDateTime.now())){return Result.fail("活动暂未开始，敬请期待！");}if(voucher.getEndTime().isBefore(LocalDateTime.now())){return Result.fail("活动已结束，请关注下次活动！");}//判断库存是否充足if(voucher.getStock() < 1){return Result.fail("库存不足，正在补充!");}Long userId = UserHolder.getUser().getId();//这一步有问题synchronized (userId.toString().intern()){return this.createVoucherOrder(voucherId);}}@Override@Transactionalpublic Result createVoucherOrder(Long voucherId) {Long userId = UserHolder.getUser().getId();log.info("开始进行用户秒杀活动：{}",userId);//一人一单逻辑Integer count = voucherOrderService.query().eq("voucher_id", voucherId).eq("user_id", userId).count();if(count > 0){return Result.fail("该用户已参加活动。");}//开始扣减库存(通过乐观锁--->对应数据库中行锁实现)boolean success  = seckillVoucherMapper.updateDateByVoucherId(voucherId);if(!success){return Result.fail("库存不足，正在补充!");}//创建订单VoucherOrder voucherOrder = new VoucherOrder();long orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);voucherOrder.setUserId(userId);voucherOrder.setVoucherId(voucherId);voucherOrderService.save(voucherOrder);return Result.ok(orderId);}
}

但是但是！还是有问题。

因为我们调用的方法，其实是this.的方式调用的，事务想要生效，还得利用代理来生效，所以这个地方，我们需要获得原始的事务对象， 来操作事务。

代理使用需要进行配置和包的引入：

org.aspectjaspectjweaver

在启动类中加入：@EnableAspectJAutoProxy(exposeProxy = true);暴露代理对象，不设置无法获取代理对象;

在调用时，通过AopContext来获取当前代理对象。

synchronized (userId.toString().intern()){//获取原始事务代理对象IVoucherOrderService iVoucherOrderService = (IVoucherOrderService) AopContext.currentProxy();return iVoucherOrderService.createVoucherOrder(voucherId);
}

Jmeter测试条件：100线程，循环1次，查看结果树和汇总报告可以看出;

查看数据库，一个用户秒杀成功一个订单，对比异常率，满足我们的需求。