基于Redis和阻塞队列的异步秒杀业务

异步前

之前的秒杀业务的查询优惠券、查询订单、减库存、创建订单都要查询数据库 ，而且有分布式锁 ，使得整个业务耗时长 ，对此采用异步操作处理，异步操作类似于餐厅点餐，服务员负责点菜产生订单、厨师负责根据订单后厨做饭，整个流程由服务员和厨师两个线程完成，此为异步。

可以看到异步优化前，1000 个请求的耗时均值 497ms

异步优化方案

将判断秒杀库存和校验一人一单的操作放在 redis 进行，优惠券库存信息也放入 redis 以减少读取数据库的压力，采用 set 集合存储购买过优惠券的用户的 id，set 集合有元素不重复的特性，可以自动实现一人一单

整体业务逻辑如下：

Redis 实现库存和秒杀资格判断（需求 1 和 2）

优惠券信息保存到 redis

修改添加秒杀券的代码，在添加秒杀券的同时把信息也保存到 redis 中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


@Override
    @Transactional
    public void addSeckillVoucher(Voucher voucher) {
        // 保存优惠券
        save(voucher);
        // 保存秒杀信息
        SeckillVoucher seckillVoucher = new SeckillVoucher();
        seckillVoucher.setVoucherId(voucher.getId());
        seckillVoucher.setStock(voucher.getStock());
        seckillVoucher.setBeginTime(voucher.getBeginTime());
        seckillVoucher.setEndTime(voucher.getEndTime());
        seckillVoucherService.save(seckillVoucher);

        //保存秒杀券信息到redis
     stringRedisTemplate.opsForValue().set("seckill:stock:"+voucher.getId(),voucher.getStock().toString());

    }

添加秒杀券，信息成功添加到 redis 中，秒杀券 id 是 13，库存是 100，如下图所示：

lua 脚本查询 redis 中库存和一人一单购买资格

seckill.lua

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


---
--- Created by 懒大王Smile.
--- DateTime: 2024/7/6 10:47
---
-- 1.参数列表
-- 1.1优惠券id
local voucherId=ARGV[1]

--1.2 用户id
local userId=ARGV[2]

--2.数据key  ..是拼接符号
--2.1 库存key
local stockKey='seckill:stock:'..voucherId
--2.2 订单key
local orderKey='seckill:order:'..voucherId

--3.脚本业务
--3.1 判断库存是否充足
if (tonumber(redis.call('get',stockKey))<=0) then
    return 1
end
--3.2判断用户是否下单   若set集合中存在该用户id，则说明已下过单，返回1
if (tonumber(redis.call('sismember',orderKey,userId))==1) then
    return 2
end

--3.4扣库存
redis.call('incrby',stockKey,-1)
--3.5保存用户到set
redis.call('sadd',orderKey,userId)
return 0

VoucherOrderServiceImpl.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder>  implements IVoucherOrderService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Resource
    private ISeckillVoucherService SeckillVoucherService;

    @Autowired
    private RedissonClient redissonClient;

    @Resource
    private RedisIdWorker redisIdWorker;

    private static final DefaultRedisScript<Long> SECKILL_SCRIPT;
    static  {
        SECKILL_SCRIPT=new DefaultRedisScript<>();
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
        SECKILL_SCRIPT.setResultType(Long.class);
    }

    @Override
    public Result seckillVoucher(Long voucherId) {
        Long userId = UserHolder.getUser().getId();
        //执行lua脚本判断有无购买资格
        Long result = stringRedisTemplate.execute(SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString()
        );
        int i = result.intValue();
        if (i!=0){
            return Result.fail(i==1?"优惠券库存不足":"不能重复下单");
        }
        long orderId = redisIdWorker.nextId("order:");
        //生成了orderId，把订单信息保存到阻塞队列，由另一个线程专门根据订单信息去数据库做增删改查，这就实现了异步

        //TODO

        return Result.ok(orderId);
    }
}

运行效果

同一用户两次下单 id 为 13 的秒杀券，第一次成功，第二次失败，如下图：

再次查看 redis 中 voucherId=13 的秒杀券，库存减 1，且该对该秒杀券下单成功的用户已经存入 set 集合，userId=1010

优化后模拟大量用户抢购秒杀券的测试

优化后，1000 个请求的耗时均值为 178ms，相比最初的 497ms 减少很多

阻塞队列实现异步秒杀下单（需求 3 和 4）

阻塞队列
当线程尝试从队列中获取元素时，若阻塞队列中无元素，则线程会阻塞，直到队列中有元素线程才会被唤醒并从阻塞队列中取出元素。

前面实现了 redis 秒杀券资格判断，若该用户有资格，则其 userId 存入 redis 订单中，且 redis 中秒杀券库存自减

订单加入阻塞队列

1
2


//定义阻塞队列
private BlockingQueue<VoucherOrder> orderTasks=new ArrayBlockingQueue<>(1024*1024);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


//订单加入阻塞队列
        //创建订单
        VoucherOrder order = new VoucherOrder();
        order.setVoucherId(voucherId);
        //TODO 生成了orderId，把订单信息保存到阻塞队列，由另一个线程专门根据订单信息去数据库做增删改查，这就实现了异步
        long orderId = redisIdWorker.nextId("order:");
        order.setId(orderId);
        order.setUserId(userId);

        //添加到阻塞队列
        orderTasks.add(order);

从阻塞队列中获取订单然后操作数据库

这里定义线程池，让线程去从阻塞队列中获取订单，实现异步操作数据库

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


//定义线程池，负责从阻塞队列中获取订单然后异步下单
    private static final ExecutorService SECKILL_ORDER_EXECUTOR= Executors.newSingleThreadExecutor();


//定义线程  这是个内部类
    private class VoucherOrderHandler implements Runnable{
        @Override
        public void run() {
            while (true){
                try {
                    //获取队列中的订单
                    VoucherOrder order = orderTasks.take();

                    //创建订单
                    handleVoucherOrder(order);

                } catch (InterruptedException e) {
                    log.error("订单处理异常",e);
                }

            }
        }
    }

//spring提供的注解  作用：类初始化后就执行VoucherOrderHandler方法
//向线程池提交一个线程
    @PostConstruct
    private void init(){
        SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    }


    private void handleVoucherOrder(VoucherOrder order) {
        Long userId = order.getUserId();

        RLock redisLock = redissonClient.getLock("lock:order:" + userId);

        boolean tryLock = redisLock.tryLock();

        //判断锁是否获取成功
        if (!tryLock){
            log.error("不允许重复下单");
            return ;
        }
        try {
            proxy.createVoucherOrder(order);
            //使用动态代理类的对象，事务可以生效
        } finally {
            redisLock.unlock();
        }
    }

完整代码