Redis实战——秒杀业务优化

我们来回顾一下下单流程

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

1、查询优惠卷

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

3、查询订单

4、校验是否是一人一单

5、扣减库存

6、创建订单

之前的秒杀业务流程图:

Redis实战——秒杀业务优化_第1张图片

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

优化方案

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

Redis实战——秒杀业务优化_第2张图片

具体实现流程:

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

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

逻辑参考下图。

Redis实战——秒杀业务优化_第3张图片

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

1. 先调用Lua脚本

2.判断结果

3.不为0,返回错误

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

5.然后订单信息

具体流程图如下:

Redis实战——秒杀业务优化_第4张图片

当然这里边有两个难点、

第一个难点是我们怎么在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 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 { @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); } }

你可能感兴趣的:(Redis,redis,数据库,java)