Redis实战——秒杀业务优化
我们来回顾一下下单流程
当用户发起请求，此时会请求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.库存不足，返回1
return 1
end
-- 3.2.判断用户是否下单 SISMEMBER orderKey userId
if(redis.call('sismember', orderKey, userId) == 1) then
-- 3.3.存在，说明是重复下单，返回2
return 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();
//在类初始化的是否就执行异步下单的任务
@PostConstruct
public void init(){
SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandle());
}
//执行异步下单的任务
private class VoucherOrderHandle implements Runnable{
@Override
public 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.库存不足，返回1
return 1
end
-- 3.2.判断用户是否下单 SISMEMBER orderKey userId
if(redis.call('sismember', orderKey, userId) == 1) then
-- 3.3.存在，说明是重复下单，返回2
return 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 0Java代码：
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 {
@Resource
private ISeckillVoucherService iSeckillVoucherService;
@Resource
private RedisIdWorker redisIdWorker;
@Resource
private StringRedisTemplate stringRedisTemplate;
@Resource
private 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();
//在类初始化的是否就执行异步下单的任务
@PostConstruct
public void init(){
SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandle());
}
//执行异步下单的任务
private class VoucherOrderHandle implements Runnable{
@Override
public void run() {
while (true){
try {
//1.获取队列中的订单信息
VoucherOrder voucherOrder = blockingQueue.take();
//2.创建订单
handlerVoucherOrder(voucherOrder);
} catch (InterruptedException e) {
log.error("获取订单信息异常{}",e);
}
}
}
}
private void handlerVoucherOrder(VoucherOrder voucherOrder) {
//获取用户id
Long 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;
@Override
public Result seckillVoucher(Long voucherId) {
Long userId = UserHolder.getUser().getId();
//1.执行lua脚本
Long result = stringRedisTemplate.execute(
SECKILL_SCRIPT,
Collections.emptyList(),
voucherId.toString(), userId.toString()
);
//2.判断返回结果是否为0
int 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添加订单id
Long orderId = redisIdWorker.nextId("order");
voucherOrder.setId(orderId);
//4.3添加用户id
voucherOrder.setUserId(userId);
//4.3添加优惠券id
voucherOrder.setVoucherId(voucherId);
blockingQueue.add(voucherOrder);
//5.获取代理对象
proxy = (IVoucherOrderService) AopContext.currentProxy();
//6.返回一个订单id
return Result.ok(order);
}
@Transactional
public 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);
}
}