我们来回顾一下下单流程

当用户发起请求，此时会请求nginx，nginx会访问到tomcat，而tomcat中的程序，会进行串行操作，分成如下几个步骤

1、查询优惠卷

2、判断秒杀库存是否足够

3、查询订单

4、校验是否是一人一单

5、扣减库存

6、创建订单

之前的秒杀业务流程图：

在这六步操作中，又有很多操作是要去操作数据库的，而且还是一个线程串行执行， 这样就会导致我们的程序执行的很慢，所以我们需要异步程序执行，那么如何加速呢？

优化方案：

我们将耗时比较短的逻辑判断放入到redis中，比如是否库存足够，比如是否一人一单，这样的操作，只要这种逻辑可以完成，就意味着我们是一定可以下单完成的，我们只需要进行快速的逻辑判断，根本就不用等下单逻辑走完，我们直接给用户返回成功， 而后再在后台开一个线程，后台线程慢慢的去执行queue（队列）里边的消息，完成创建订单的动作（异步操作创建订单）。这样程序不就超级快了吗？而且也不用担心线程池消耗殆尽的问题，因为这里我们的程序中并没有手动使用任何线程池。

具体实现流程：

首先，在Reids中进行判断是否符合条件，我们可以使用redis中list类型的方法存入用户信息，key订单key，value就传入用户id（多个，所以使用list类型方法），并且在redis中存入库存信息。

然后编写Lua脚本实现业务逻辑，实现判断用户是否有资格下单。

逻辑参考下图。

 编写完Lua脚本后，就可以在Java中执行对于的业务逻辑了

1. 先调用Lua脚本

2.判断结果

3.不为0，返回错误

4.为0，用户符合条件，将订单信息传入到阻塞队列中，并开启线程异步创建订单

5.然后订单信息

具体流程图如下：

当然这里边有两个难点、

第一个难点是我们怎么在redis中去快速校验一人一单，还有库存判断？

第二个难点是如何将订单信息放入到阻塞队列中，并创建一个新的线程异步创建订单？

对于使用Redis中去快速校验一人一单，还有库存判断，上述已经讲过，就是使用Lua脚本

具体Lua脚本代码：

-- 1.参数列表
-- 1.1.优惠券id
local voucherId = ARGV[1]
-- 1.2.用户id
local userId = ARGV[2]
-- 1.3.订单id
local orderId = ARGV[3]-- 2.数据key
-- 2.1.库存key
local stockKey = 'seckill:stock:' .. voucherId
-- 2.2.订单key
local orderKey = 'seckill:order:' .. voucherId-- 3.脚本业务
-- 3.1.判断库存是否充足 get stockKey
if(tonumber(redis.call('get', stockKey)) <= 0) then-- 3.2.库存不足，返回1return 1
end
-- 3.2.判断用户是否下单 SISMEMBER orderKey userId
if(redis.call('sismember', orderKey, userId) == 1) then-- 3.3.存在，说明是重复下单，返回2return 2
end
-- 3.4.扣库存 incrby stockKey -1
redis.call('incrby', stockKey, -1)
-- 3.5.下单（保存用户）sadd orderKey userId
redis.call('sadd', orderKey, userId)
-- 3.6.发送消息到队列中， XADD stream.orders * k1 v1 k2 v2 ...
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
return 0

然后就是将订单信息放入到阻塞队列中，并创建一个新的线程异步创建订单：

温馨提示：这只是一个伪代码~ 具体代码实现在最下方

我们可以使用下述代码创建一个阻塞队列和异步创建订单

创建阻塞队列：

BlockingQueue blockingQueue = new ArrayBlockingQueue<>(1024*1024)
//保存订单信息
blockingQueue.add(voucherOrder);
//获取订单信息
blockingQueue.tack();

异步创建订单： 

    BlockingQueue blockingQueue = new ArrayBlockingQueue<>(1024*1024)//获取线程池private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();//在类初始化的是否就执行异步下单的任务@PostConstructpublic void init(){SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandle());}//执行异步下单的任务private class VoucherOrderHandle implements Runnable{@Overridepublic void run() {while (true){try {//1.获取队列中的订单信息VoucherOrder voucherOrder = blockingQueue.take();//2.创建订单handlerVoucherOrder(voucherOrder);} catch (InterruptedException e) {log.error("获取订单信息异常{}",e);}}}}

完整代码：

Lua脚本：

-- 1.参数列表
-- 1.1.优惠券id
local voucherId = ARGV[1]
-- 1.2.用户id
local userId = ARGV[2]
-- 1.3.订单id
local orderId = ARGV[3]-- 2.数据key
-- 2.1.库存key
local stockKey = 'seckill:stock:' .. voucherId
-- 2.2.订单key
local orderKey = 'seckill:order:' .. voucherId-- 3.脚本业务
-- 3.1.判断库存是否充足 get stockKey
if(tonumber(redis.call('get', stockKey)) <= 0) then-- 3.2.库存不足，返回1return 1
end
-- 3.2.判断用户是否下单 SISMEMBER orderKey userId
if(redis.call('sismember', orderKey, userId) == 1) then-- 3.3.存在，说明是重复下单，返回2return 2
end
-- 3.4.扣库存 incrby stockKey -1
redis.call('incrby', stockKey, -1)
-- 3.5.下单（保存用户）sadd orderKey userId
redis.call('sadd', orderKey, userId)
-- 3.6.发送消息到队列中， XADD stream.orders * k1 v1 k2 v2 ...
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
return 0

Java代码： 

package com.hmdp.service.impl;import com.hmdp.dto.Result;
import com.hmdp.entity.VoucherOrder;
import com.hmdp.mapper.VoucherOrderMapper;
import com.hmdp.service.ISeckillVoucherService;
import com.hmdp.service.IVoucherOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.utils.RedisIdWorker;
import com.hmdp.utils.UserHolder;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.aop.framework.AopContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.Collections;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*** 
*  服务实现类* 
** @author 虎哥* @since 2021-12-22*/
@Service
@Slf4j
public class VoucherOrderServiceImpl extends ServiceImpl implements IVoucherOrderService {@Resourceprivate ISeckillVoucherService iSeckillVoucherService;@Resourceprivate RedisIdWorker redisIdWorker;@Resourceprivate StringRedisTemplate stringRedisTemplate;@Resourceprivate RedissonClient redissonClient;//获取lua脚本private static final DefaultRedisScript SECKILL_SCRIPT;static {SECKILL_SCRIPT = new DefaultRedisScript<>();SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));SECKILL_SCRIPT.setResultType(Long.class);}//获取阻塞队列private BlockingQueue blockingQueue = new ArrayBlockingQueue<>(1024*1024);//获取线程池private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();//在类初始化的是否就执行异步下单的任务@PostConstructpublic void init(){SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandle());}//执行异步下单的任务private class VoucherOrderHandle implements Runnable{@Overridepublic void run() {while (true){try {//1.获取队列中的订单信息VoucherOrder voucherOrder = blockingQueue.take();//2.创建订单handlerVoucherOrder(voucherOrder);} catch (InterruptedException e) {log.error("获取订单信息异常{}",e);}}}}private void handlerVoucherOrder(VoucherOrder voucherOrder) {//获取用户idLong userId = voucherOrder.getUserId();//1.创建锁对象//SimpleRedisLock lock = new SimpleRedisLock(stringRedisTemplate, "order:" + userId);RLock lock = redissonClient.getLock("order:" + userId);//2.尝试获取锁boolean isLock = lock.tryLock();if (!isLock){//获取锁失败log.error("获取锁失败");return;}try {proxy.createVoucherOrder(voucherOrder);} finally {//释放锁lock.unlock();}}private IVoucherOrderService proxy;@Overridepublic Result seckillVoucher(Long voucherId) {Long userId = UserHolder.getUser().getId();//1.执行lua脚本Long result = stringRedisTemplate.execute(SECKILL_SCRIPT,Collections.emptyList(),voucherId.toString(), userId.toString());//2.判断返回结果是否为0int r = result.intValue();if (r != 0) {//3.如果不为0，代表没有下单资格Result.fail(r==1?"库存不足!":"不可重复下单!");}//4.如果为0，有购买资格，把下单信息保存到阻塞队列long order = redisIdWorker.nextId("order");//4.1 创建订单VoucherOrder voucherOrder = new VoucherOrder();//4.2添加订单idLong orderId = redisIdWorker.nextId("order");voucherOrder.setId(orderId);//4.3添加用户idvoucherOrder.setUserId(userId);//4.3添加优惠券idvoucherOrder.setVoucherId(voucherId);blockingQueue.add(voucherOrder);//5.获取代理对象proxy = (IVoucherOrderService) AopContext.currentProxy();//6.返回一个订单idreturn Result.ok(order);}@Transactionalpublic void createVoucherOrder(VoucherOrder voucherOrder) {Long userId = voucherOrder.getUserId();//6.根据优惠券id和用户id判断订单是否已经存在//如果存在，则返回错误信息int count = query().eq("user_id", userId).eq("voucher_id", voucherOrder.getVoucherId()).count();if (count > 0) {log.error("用户已经购买!");return;}boolean success = iSeckillVoucherService.update().setSql("stock=stock-1").eq("voucher_id", voucherOrder.getVoucherId()).gt("stock", 0).update();if (!success){//扣减失败log.error("扣减失败");return;}save(voucherOrder);}
}