实现秒杀下单

1. 订单Id生成策略
2. 业务逻辑
   
3. 代码实现

public class VoucherOrderServiceImpl extends ServiceImpl implements IVoucherOrderService {@Autowiredprivate ISeckillVoucherService iSeckillVoucherService;@Autowiredprivate RedisIdWorker redisIdWorker;@Override@Transactionalpublic Result seckillVoucher(Long voucherId) {//1.查询优惠券SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);//2.判断秒杀是否开始if(voucher.getBeginTime().isAfter(LocalDateTime.now())){return Result.fail("秒杀尚未开始！");}//3.判断秒杀是否结束if(voucher.getEndTime().isBefore(LocalDateTime.now())){return Result.fail("秒杀已经结束！");}//4.判断库存是否充足if(voucher.getStock() < 1){return Result.fail("库存不足！");}//5.扣减库存boolean success = iSeckillVoucherService.update().setSql("stock = stock -1").eq("voucher_id",voucherId).update();if(!success){//扣减失败return Result.fail("库存不足！");}//6.创建订单VoucherOrder voucherOrder = new VoucherOrder();//6.1 订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);//6.2 用户idLong userId = UserHolder.getUser().getId();voucherOrder.setUserId(userId);//6.3 代金券idvoucherOrder.setVoucherId(voucherId);//6.4 记录数据库save(voucherOrder);//7.返回订单idreturn Result.ok(orderId);}
}

优化一：乐观锁解决库存超卖问题

1. 在高并发的情况是会出现库存超卖问题的，解决方案一：用乐观锁。
2. 乐观锁解决方案：
   • 版本号法
   • CAS（CompareAndSwap）法：比较并交换
3. 代码实现：在扣减库存的时候判断此时库存是否大于0。

public class VoucherOrderServiceImpl extends ServiceImpl implements IVoucherOrderService {@Autowiredprivate ISeckillVoucherService iSeckillVoucherService;@Autowiredprivate RedisIdWorker redisIdWorker;@Override@Transactionalpublic Result seckillVoucher(Long voucherId) {//1.查询优惠券SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);//2.判断秒杀是否开始if(voucher.getBeginTime().isAfter(LocalDateTime.now())){return Result.fail("秒杀尚未开始！");}//3.判断秒杀是否结束if(voucher.getEndTime().isBefore(LocalDateTime.now())){return Result.fail("秒杀已经结束！");}//4.判断库存是否充足if(voucher.getStock() < 1){return Result.fail("库存不足！");}//5.扣减库存boolean success = iSeckillVoucherService.update().setSql("stock = stock -1") // set stock = stock -1.eq("voucher_id",voucherId).gt("stock",0) // where id = ? and stock > 0.update();if(!success){//扣减失败return Result.fail("库存不足！");}//6.创建订单VoucherOrder voucherOrder = new VoucherOrder();//6.1 订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);//6.2 用户idLong userId = UserHolder.getUser().getId();voucherOrder.setUserId(userId);//6.3 代金券idvoucherOrder.setVoucherId(voucherId);//6.4 记录数据库save(voucherOrder);//7.返回订单idreturn Result.ok(orderId);}
}

优化二：使用悲观锁实现“一人一单”

通过synchronized来给每一个用户的id加锁

public class VoucherOrderServiceImpl extends ServiceImpl implements IVoucherOrderService {@Autowiredprivate ISeckillVoucherService iSeckillVoucherService;@Autowiredprivate RedisIdWorker redisIdWorker;@Overridepublic Result seckillVoucher(Long voucherId) {//1.查询优惠券SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);//2.判断秒杀是否开始if(voucher.getBeginTime().isAfter(LocalDateTime.now())){return Result.fail("秒杀尚未开始！");}//3.判断秒杀是否结束if(voucher.getEndTime().isBefore(LocalDateTime.now())){return Result.fail("秒杀已经结束！");}//4.判断库存是否充足if(voucher.getStock() < 1){return Result.fail("库存不足！");}//7.返回订单idLong userId = UserHolder.getUser().getId();//对同一用户的id进行加锁，如果直接在createVoucherOrder这个方法里加锁，会导致先释放锁在提交事务，这样还是会有问题。//事务的管理是通过代理对象来的，所以先创建一个代理对象来synchronized (userId.toString().intern()){//获取代理对象（事务）IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();return proxy.createVoucherOrder(voucherId);}}@Transactionalpublic Result createVoucherOrder(Long voucherId){Long userId = UserHolder.getUser().getId();//5. 一人一单//5.1 查询订单Integer count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();if (count > 0) {return Result.fail("用户已经购买过一次！");}//6.扣减库存boolean success = iSeckillVoucherService.update().setSql("stock = stock -1") // set stock = stock -1.eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0.update();if (!success) {//扣减失败return Result.fail("库存不足！");}//7.创建订单VoucherOrder voucherOrder = new VoucherOrder();//6.1 订单idlong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);//6.2 用户idvoucherOrder.setUserId(userId);//6.3 代金券idvoucherOrder.setVoucherId(voucherId);//6.4 记录数据库save(voucherOrder);return Result.ok(voucherId);}
}

优化三：Redis分布式锁实现“一人一单“，解决多台服务器上分布sychronize锁不一致的问题

核心代码实现：利用设置键的同时设置它的过期时间（这样时间一到这个键也就失效了），中间执行业务，最后再释放锁。以此可以实现防止同个用户下多单的情况。

Long userId = UserHolder.getUser().getId();//创建锁对象SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);//获取锁，同一个用户一旦获取了锁之后，他就不能在同一时间在继续访问了，等到锁被释放，此时用户下单记录已经被记住数据库了，实现了”一人一单“的功能boolean isLock = lock.tryLock(500);//判断是否获锁成功if(!isLock){//获取锁失败return Result.fail("不允许重复下单");}try{//获取代理对象（事务）IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();return proxy.createVoucherOrder(voucherId);}finally {//释放锁lock.unlock();}

完整代码：

@Overridepublic Result seckillVoucher(Long voucherId) {//1.查询优惠券SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);//2.判断秒杀是否开始if(voucher.getBeginTime().isAfter(LocalDateTime.now())){return Result.fail("秒杀尚未开始！");}//3.判断秒杀是否结束if(voucher.getEndTime().isBefore(LocalDateTime.now())){return Result.fail("秒杀已经结束！");}//4.判断库存是否充足if(voucher.getStock() < 1){return Result.fail("库存不足！");}Long userId = UserHolder.getUser().getId();//创建锁对象SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);//获取锁，同一个用户一旦获取了锁之后，他就不能在同一时间在继续访问了，等到锁被释放，此时用户下单记录已经被记住数据库了，实现了”一人一单“的功能boolean isLock = lock.tryLock(500);//判断是否获锁成功if(!isLock){//获取锁失败return Result.fail("不允许重复下单");}try{//获取代理对象（事务）IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();return proxy.createVoucherOrder(voucherId);}finally {//释放锁lock.unlock();}}

优化四：Redis锁的误删问题：一个线程把另外一个线程的锁给删了

解决方法：给每一个线程一个唯一的标识号，当删锁的时候取出当前线程的标识号，并与锁的标识号比较，一致才可以删。

public class SimpleRedisLock implements ILock {private StringRedisTemplate stringRedisTemplate;private String name; // 业务名称public SimpleRedisLock(String name,StringRedisTemplate stringRedisTemplate){this.name = name;this.stringRedisTemplate = stringRedisTemplate;}private static final String KEY_PREFIX = "lock:";private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";/*** 获取锁* @param timeoutSec 锁持有的超时时间，过期后自动释放* @return*/@Overridepublic boolean tryLock(long timeoutSec) {// 获取线程标识String threadId = ID_PREFIX + Thread.currentThread().getId();// 获取锁Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);return Boolean.TRUE.equals(success);}@Overridepublic void unlock() {// 获取线程标识String threadId = ID_PREFIX + Thread.currentThread().getId();// 获取锁中的标示String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);// 判断标识是否一致if(threadId.equals(id)){//释放锁stringRedisTemplate.delete(KEY_PREFIX + name);}}
}

优化五：分布式锁的原子性问题（获取锁和释放锁之间是有间隔的，可能在获取可以释放锁信号之后要删锁，突然间发生了业务阻塞，于是又把别人的锁给删了）。

1.原来没有原子性原因：if判断和删除锁操作是没有原子性的，在判断和删除之间可能会发生事务阻塞，导致误删锁。

if(threadId.equals(id)){//释放锁stringRedisTemplate.delete(KEY_PREFIX + name);}

2.解决方法：利用lua脚本来实现原子性
lua脚本：

-- 比较线程标识与锁中的标识是否一致
if(redis.call('get',KEYS[1]) == ARGV[1]) then-- 释放锁 del keyreturn redis.call('del',KEYS[1])
end
return 0

java代码实现：

 @Overridepublic void unlock() {// 调用lua脚本stringRedisTemplate.execute(unlock_script,Collections.singletonList(KEY_PREFIX + name), // 键ID_PREFIX + Thread.currentThread().getId()); // 线程标识}

基于redis分布式锁的总结