Redis之秒杀下单优化以及认识redis消息队列

Posted 爱上口袋的天空

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Redis之秒杀下单优化以及认识redis消息队列相关的知识,希望对你有一定的参考价值。

目录

一、秒杀优化 - 异步秒杀思路

二、秒杀优化 - Redis 完成秒杀资格判断

 1、VoucherServiceImpl,新增优惠券的同时加入到Redis

 2、编写lua,基于lua完成一人一单,seckill.lua

3、调用seckill.lua脚本,VoucherOrderServiceImpl

 4、基于阻塞队列实现秒杀异步下单

5、小总结

 三、认识Redis消息队列

1、认识消息队列

2、Redis 消息队列 - 基于 List 实现消息队列

3、Redis 消息队列 - 基于 PubSub 的消息队列

4、Redis 消息队列 - 基于 Stream 的消息队列

5、Redis 消息队列 - 基于 Stream 的消息队列 - 消费者组

 6、基于 Redis 的 Stream 结构作为消息队列,实现异步秒杀下单

1)控制台stream类型创建消息队列

 2)  修改Lua脚本

 3) 修改执行lua脚本

4) 获取消息队列中的消息

 5) 加锁,创建订单


一、秒杀优化 - 异步秒杀思路

我们来回顾一下下单流程

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

  1. 查询优惠卷
  2. 判断秒杀库存是否足够
  3. 查询订单
  4. 校验是否是一人一单
  5. 扣减库存
  6. 创建订单

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

        在这里笔者想给大家分享一下课程内没有的思路,看看有没有小伙伴这么想,比如,我们可以不可以使用异步编排来做,或者说我开启 N 多线程,N 多个线程,一个线程执行查询优惠卷,一个执行判断扣减库存,一个去创建订单等等,然后再统一做返回,这种做法和课程中有哪种好呢?答案是课程中的好,因为如果你采用我刚说的方式,如果访问的人很多,那么线程池中的线程可能一下子就被消耗完了,而且你使用上述方案,最大的特点在于,你觉得时效性会非常重要,但是你想想是吗?并不是,比如我只要确定他能做这件事,然后我后边慢慢做就可以了,我并不需要他一口气做完这件事,所以我们应当采用的是课程中,类似消息队列的方式来完成我们的需求,而不是使用线程池或者是异步编排的方式来完成这个需求

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

  • 第一个难点是我们怎么在 redis 中去快速校验一人一单,还有库存判断
  • 第二个难点是由于我们校验和 tomct 下单是两个线程,那么我们如何知道到底哪个单他最后是否成功,或者是下单完成,为了完成这件事我们在 redis 操作完之后,我们会将一些信息返回给前端,同时也会把这些信息丢到异步 queue 中去,后续操作中,可以通过这个 id 来查询我们 tomcat 中的下单逻辑是否完成了。

        我们现在来看看整体思路:当用户下单之后,判断库存是否充足只需要导 redis 中去根据 key 找对应的 value 是否大于 0 即可,如果不充足,则直接结束,如果充足,继续在 redis 中判断用户是否可以下单,如果 set 集合中没有这条数据,说明他可以下单,如果 set 集合中没有这条记录,则将 userId 和优惠卷存入到 redis 中,并且返回 0,整个过程需要保证是原子性的,我们可以使用 lua 来操作

        当以上判断逻辑走完之后,我们可以判断当前 redis 中返回的结果是否是 0 ,如果是 0,则表示可以下单,则将之前说的信息存入到到 queue 中去,然后返回,然后再来个线程异步的下单,前端可以通过返回的订单 id 来判断是否下单成功。


二、秒杀优化 - Redis 完成秒杀资格判断

需求:

  • 新增秒杀优惠券的同时,将优惠券信息保存到 Redis 中
  • 基于 Lua 脚本,判断秒杀库存、一人一单,决定用户是否抢购成功
  • 如果抢购成功,将优惠券 id 和用户 id 封装后存入阻塞队列
  • 开启线程任务,不断从阻塞队列中获取信息,实现异步下单功能

 1、VoucherServiceImpl,新增优惠券的同时加入到Redis

@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中
    //SECKILL_STOCK_KEY 这个变量定义在RedisConstans中
    //private static final String SECKILL_STOCK_KEY ="seckill:stock:"
    stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());

 2、编写lua,基于lua完成一人一单,seckill.lua

-- 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判断用户是否下单 sismember orderKey userId
if(redis.call('sismember',orderKey,userId)==1)
    then return 2
end
-- 3.3扣库存 incrby stockKey -1
redis.call('incrby',stockKey,-1)
-- 3.4下单 sadd orderKey userId
redis.call('sadd',orderKey,userId)
return 0

3、调用seckill.lua脚本,VoucherOrderServiceImpl

// DefaultRedisScript,
    private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

    // 初始化 SECKILL_SCRIPT,用静态代码块的方式,一加载VoucherOrderServiceImpl有会加载seckill.lua
    // 避免每次调unLock() 才去加载,提升性能!!!
    static 
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        // setLocation() 设置脚本位置
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
        // 返回值类型
        SECKILL_SCRIPT.setResultType(Long.class);
    
 @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()
        );
        int r = result.intValue();
        // 2.判断结果是否为0
        if (r != 0) 
            // 2.1.不为0 ,代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
        
        long orderId = redisIdWorker.nextId("order");
        //TODO 保存阻塞队列
        // 3.返回订单id
        return Result.ok(orderId);
    

 4、基于阻塞队列实现秒杀异步下单

之前的代码逻辑:

 完善后的完整代码:

package com.hmdp.service.impl;

import com.hmdp.dto.Result;
import com.hmdp.entity.SeckillVoucher;
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 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.time.LocalDateTime;
import java.util.Collections;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2021-12-22
 */
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService 

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private RedisIdWorker redisIdWorker;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Resource
    private RedissonClient redissonClient;

    // DefaultRedisScript,
    private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

    // 初始化 SECKILL_SCRIPT,用静态代码块的方式,一加载VoucherOrderServiceImpl有会加载seckill.lua
    // 避免每次调unLock() 才去加载,提升性能!!!
    static 
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        // setLocation() 设置脚本位置
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
        // 返回值类型
        SECKILL_SCRIPT.setResultType(Long.class);
    

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

    private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();//创建线程池

    IVoucherOrderService proxy;

    // 类加载后就持续从阻塞队列出取出订单信息
    @PostConstruct
    private void init()
        SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    

    @Override
    public Result seckillVoucher(Long voucherId) 
        //1.查询优惠卷
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        //2.判断秒杀是否开始,是否结束
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())) 
            return Result.fail("秒杀尚未开始!");
        
        if(voucher.getEndTime().isBefore(LocalDateTime.now()))
            return Result.fail("秒杀已结束!");
        
        //3.判断库存是否充足
        if(voucher.getStock()<=0)
            return Result.fail("优惠券库存不足!");
        

        //获取用户
        Long userId = UserHolder.getUser().getId();

        // 1.执行lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString()
        );
        int r = result.intValue();
        // 2.判断结果是否为0
        if (r != 0) 
            // 2.1.不为0 ,代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
        
        //生成订单id
        long orderId = redisIdWorker.nextId("order");
        //创建订单数据
        VoucherOrder voucherOrder = new VoucherOrder();
        voucherOrder.setUserId(userId);
        voucherOrder.setId(orderId);
        voucherOrder.setVoucherId(voucherId);
        //放入阻塞队列
        orderTasks.add(voucherOrder);
        //获取代理对象
        proxy = (IVoucherOrderService) AopContext.currentProxy();//获得代理对象
        //3.返回订单id
        return Result.ok(orderId);
    

    private class VoucherOrderHandler implements Runnable
        @Override
        public void run() 
            while(true)
                try 
                    //1.获取订单中的队列消息
                    VoucherOrder voucherOrder = orderTasks.take();
                    handleVoucherOrder(voucherOrder);
                    //2.创建订单
                 catch (Exception e) 
                    log.error("处理订单异常:",e);
                
            
        
    

    //异步下单
    private void handleVoucherOrder(VoucherOrder voucherOrder) 
        Long userId = voucherOrder.getUserId();//由于多线程,所以不能直接去ThreadLocal取
        //创建锁对象
        //SimpleRedisLock lock = new SimpleRedisLock("order:" + userId,stringRedisTemplate);
        RLock lock = redissonClient.getLock("lock:order:" + userId);
        //获取锁
        boolean hasLock = lock.tryLock( );
        if(!hasLock)
            //获取锁失败
            log.error("不允许重复下单!");
            return;
        

        try 
            //代理对象改成全局变量
            proxy.createVoucherOrder(voucherOrder);//默认是this,我们要实现事务需要proxy
         catch (IllegalStateException e) 
            throw new RuntimeException(e);
         finally 
            lock.unlock();
        

    

    @Transactional
    public void createVoucherOrder(VoucherOrder voucherOrder)
        //查询订单看看是否存在
        Long userId = UserHolder.getUser().getId();

        if (query().eq("user_id",userId).eq("voucher_id", voucherOrder.getUserId()).count()>0) 
            log.error("用户已经购买过一次!");
            return;
        

        //4.扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock -1")
                .eq("voucher_id", voucherOrder.getVoucherId()).gt("stock",0)//where id = ? and stock >0 添加了乐观锁
                .update();

        if(!success)
            log.error("优惠券库存不足!");
            return;
        

        //7.订单写入数据库
        save(voucherOrder);
    

    /*@Override
    public Result seckillVoucher(Long voucherId) 
        // 1. 查询优惠券
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        LocalDateTime nowTime = LocalDateTime.now();

        // 2. 判断秒杀是否开始
        if (nowTime.isBefore(voucher.getBeginTime())) 
            return Result.fail("活动未开始!");
        

        // 3. 判断秒杀是否结束
        if (nowTime.isAfter(voucher.getEndTime())) 
            return Result.fail("活动已结束!");
        

        // 4. 判断库存
        if (voucher.getStock() < 1) 
            return Result.fail("已买完!");
        

        Long userId = UserHolder.getUser().getId();

        // 创建锁对象
        SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
        // 获取锁 1200s
        boolean isLock = lock.tryLock(1200);
        if (!isLock) 
            return Result.fail("不允许重复下单!");
        
        try 
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
         finally 
            lock.unlock();
        
    */

5、小总结

秒杀业务的优化思路是什么?

  • 先利用 Redis 完成库存余量、一人一单判断,完成抢单业务
  • 再将下单业务放入阻塞队列,利用独立线程异步下单
  • 基于阻塞队列的异步秒杀存在哪些问题?
    • 内存限制问题
    • 数据安全问题

 三、认识Redis消息队列

上面我们基于jvm的阻塞队列进行秒杀存在2个问题:

  1. jvm的内存限制问题

  2. 数据安全问题:jvm的内存数据没有持久化,每当服务器重启或者宕机或者从阻塞队列取的时候遇到异常,数据都会丢失

    解决方法: 消息队列

1、认识消息队列

什么是消息队列:字面意思就是存放消息的队列。最简单的消息队列模型包括 3 个角色:

  • 消息队列:存储和管理消息,也被称为消息代理(Message Broker)
  • 生产者:发送消息到消息队列
  • 消费者:从消息队列获取消息并处理消息

        使用队列的好处在于 解耦:所谓解耦,举一个生活中的例子就是:快递员 (生产者) 把快递放到快递柜里边 (Message Queue) 去,我们 (消费者) 从快递柜里边去拿东西,这就是一个异步,如果耦合,那么这个快递员相当于直接把快递交给你,这事固然好,但是万一你不在家,那么快递员就会一直等你,这就浪费了快递员的时间,所以这种思想在我们日常开发中,是非常有必要的。

        这种场景在我们秒杀中就变成了:我们下单之后,利用 redis 去进行校验下单条件,再通过队列把消息发送出去,然后再启动一个线程去消费这个消息,完成解耦,同时也加快我们的响应速度。

        这里我们可以使用一些现成的 mq,比如 kafka,rabbitmq 等等,但是呢,如果没有安装 mq,我们也可以直接使用 redis 提供的 mq 方案,降低我们的部署和学习成本。

2、Redis 消息队列 - 基于 List 实现消息队列

消息队列(Message Queue),字面意思就是存放消息的队列。而 Redis 的 list 数据结构是一个双向链表,很容易模拟出队列效果。

        队列是入口和出口不在一边,因此我们可以利用:LPUSH 结合 RPOP、或者 RPUSH 结合 LPOP 来实现
        不过要注意的是,当队列中没有消息时 RPOP 或 LPOP 操作会返回 null,并不像 JVM 的阻塞队列那样会阻塞并等待消息。因此这里应该使用 BRPOP 或者 BLPOP 来实现阻塞效果

 基于 List 的消息队列有哪些优缺点?
优点:

  • 利用 Redis 存储,不受限于 JVM 内存上限
  • 基于 Redis 的持久化机制,数据安全性有保证
  • 可以满足消息有序性

缺点:

  • 无法避免消息丢失
  • 只支持单消费者

3、Redis 消息队列 - 基于 PubSub 的消息队列

        PubSub(发布订阅)是 Redis2.0 版本引入的消息传递模型。顾名思义,消费者可以订阅一个或多个 channel,生产者向对应 channel 发送消息后,所有订阅者都能收到相关消息。

  • SUBSCRIBE channel [channel] :订阅一个或多个频道
  • PUBLISH channel msg :向一个频道发送消息
  • PSUBSCRIBE pattern [pattern] :订阅与 pattern 格式匹配的所有频道

基于 PubSub 的消息队列有哪些优缺点?
优点:

  • 采用发布订阅模型,支持多生产、多消费

缺点:

  • 不支持数据持久化
  • 无法避免消息丢失
  • 消息堆积有上限,超出时数据丢失

4、Redis 消息队列 - 基于 Stream 的消息队列

Stream 是 Redis 5.0 引入的一种新数据类型,可以实现一个功能非常完善的消息队列。

发送消息的命令:

 例如:

 读取消息的方式之一:XREAD

 例如,使用 XREAD 读取第一个消息:

 XREAD 阻塞方式,读取最新的消息:

在业务开发中,我们可以循环的调用 XREAD 阻塞方式来查询最新消息,从而实现持续监听队列的效果,伪代码如下

注意:当我们指定起始 ID 为 $ 时,代表读取最新的消息,如果我们处理一条消息的过程中,又有超过 1 条以上的消息到达队列,则下次获取时也只能获取到最新的一条,会出现漏读消息的问题

STREAM 类型消息队列的 XREAD 命令特点:

  • 消息可回溯
  • 一个消息可以被多个消费者读取
  • 可以阻塞读取
  • 有消息漏读的风险

5、Redis 消息队列 - 基于 Stream 的消息队列 - 消费者组

消费者组(Consumer Group):将多个消费者划分到一个组中,监听同一个队列。具备下列特点:

 创建消费者组:

  • key:队列名称
  • groupName:消费者组名称
  • ID:起始 ID 标示,$ 代表队列中最后一个消息,0 则代表队列中第一个消息
  • MKSTREAM:队列不存在时自动创建队列

其它常见命令:

1)删除指定的消费者组

XGROUP DESTORY key groupName

 2)给指定的消费者组添加消费者

XGROUP CREATECONSUMER key groupname consumername

 3)删除消费者组中的指定消费者

XGROUP DELCONSUMER key groupname consumername

 4)从消费者组读取消息:

XREADGROUP GROUP group consumer [COUNT count] [BLOCK milliseconds] [NOACK] STREAMS key [key ...] ID [ID ...]
  • group:消费组名称
  • consumer:消费者名称,如果消费者不存在,会自动创建一个消费者
  • count:本次查询的最大数量
  • BLOCK milliseconds:当没有消息时最长等待时间
  • NOACK:无需手动 ACK,获取到消息后自动确认
  • STREAMS key:指定队列名称
  • ID:获取消息的起始 ID:

“>”:从下一个未消费的消息开始
其它:根据指定 id 从 pending-list 中获取已消费但未确认的消息,例如 0,是从 pending-list 中的第一个消息开始

消费者监听消息的基本思路:

 STREAM 类型消息队列的 XREADGROUP 命令特点:

  • 消息可回溯
  • 可以多消费者争抢消息,加快消费速度
  • 可以阻塞读取
  • 没有消息漏读的风险
  • 有消息确认机制,保证消息至少被消费一次

最后我们来个小对比

 6、基于 Redis 的 Stream 结构作为消息队列,实现异步秒杀下单

需求:

  • 创建一个 Stream 类型的消息队列,名为 stream.orders
  • 修改之前的秒杀下单 Lua 脚本,在认定有抢购资格后,直接向 stream.orders 中添加消息,内容包含 voucherId、userId、orderId
  • 项目启动时,开启一个线程任务,尝试获取 stream.orders 中的消息,完成下单 

1)控制台stream类型创建消息队列

xgroup create stream.orders g1 0 mkstream

 2)  修改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判断库存是否充足
if (tonumber(redis.call('get', stockKey)) <= 0)
    then return 1
end
-- 3.2判断用户是否下单 sismember orderKey userId
if(redis.call('sismember',orderKey,userId)==1)
    then return 2
end
-- 3.3扣库存 incrby stockKey -1
redis.call('incrby',stockKey,-1)
-- 3.4下单 sadd orderKey userId
redis.call('sadd',orderKey,userId)

--4.发送消息到消息队列, xadd stream.order * k1 v1 k2 v2
redis.call('xadd','stream.order','*','userId',userId,'voucherId',voucherId,'id',orderId) --新增
return 0

 3) 修改执行lua脚本

private IVoucherOrderService proxy;
public Result seckillVoucher(Long voucherId) 
    //1.查询优惠卷
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
    //2.判断秒杀是否开始,是否结束
    if (voucher.getBeginTime().isAfter(LocalDateTime.now())) 
        return Result.fail("秒杀尚未开始!");
    
    if(voucher.getEndTime().isBefore(LocalDateTime.now()))
        return Result.fail("秒杀已结束!");
    
    //3.判断库存是否充足
    if(voucher.getStock()<=0)
        return Result.fail("优惠券库存不足!");
    
    //获取当前用户
    Long userId = UserHolder.getUser().getId();
    //生成订单id
    long orderId = redisIdWorker.nextId("order");
    //1.执行Lua脚本
    Long result = stringRedisTemplate.execute(
            SECKI_SCRIPT,
            Collections.emptyList(),//空List
            voucherId.toString(), userId.toString(),String.valueOf(orderId)
    );
    //2.判断结果是否0 是0就是成功,可下单,下单信息保存到阻塞队列
    if(result!=0)
        return Result.fail(result==1?"库存不足!":"不能重复下单!");
    
    //获取代理对象
    proxy = (IVoucherOrderService) AopContext.currentProxy();//获得代理对象
    //3.返回订单id
    return Result.ok(orderId);


4) 获取消息队列中的消息

private class VoucherOrderHandler implements Runnable

    @Override
    public void run() 
        while(true)
            try 
                //1.获取消息队列中的消息 xreadgroup group g1 c1 count 1 block 2000 streams stream.orders >
                List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                        Consumer.from("g1", "c1"),
                        StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
                        StreamOffset.create("stream.orders", ReadOffset.lastConsumed())
                );
                //2.判断获取是否成功
                //3.失败就再循环
                if(list==null||list.isEmpty())
                    continue;
                
                //4.成功就创建订单且ACK确认
                //解析消息
                MapRecord<String, Object, Object> record = list.get(0);//消息id,key,value
                //取出每个消息
                Map<Object, Object> values = record.getValue();
                //转为VoucherOrder实体类
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(values, new VoucherOrder(), true);
                //创建订单
                handleVoucherOrder(voucherOrder);
                //ACK确认
                stringRedisTemplate.opsForStream().acknowledge("stream.orders","g1",record.getId());
             catch (Exception e) 
                log.error("处理订单异常:",e);
                //5.出现异常,从pendingList中取出数据后重新操作
                handlePendingList();
            
        
    


private void handlePendingList() 
    while (true) 
        try 
            // 1. 获取 pending-list 中的订单信息
            // XREAD GROUP orderGroup consumerOne COUNT 1 STREAM stream.orders 0
            List<MapRecord<String, Object, Object>> readingList = stringRedisTemplate.opsForStream().read(
                    Consumer.from("g1", "c1"),
                    StreamReadOptions.empty().count(1),
                    StreamOffset.create("stream.orders", ReadOffset.from("0"))
            );

            // 2. 判断消息是否获取成功
            if (readingList.isEmpty() || readingList == null) 
                // 获取失败 pending-list 中没有异常消息,结束循环
                break;
            

            // 3. 解析消息中的订单信息并下单
            MapRecord<String, Object, Object> record = readingList.get(0);
            Map<Object, Object> recordValue = record.getValue();
            VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(recordValue, new VoucherOrder(), true);
            handleVoucherOrder(voucherOrder);

            // 4. XACK
            stringRedisTemplate.opsForStream().acknowledge("stream.orders", "g1", record.getId());
         catch (Exception e) 
            log.error("订单处理异常(pending-list)", e);
            try 
                // 稍微休眠一下再进行循环
                Thread.sleep(10);
             catch (Exception ex) 
                ex.printStackTrace();
            
        
    

 5) 加锁,创建订单

private void handleVoucherOrder(VoucherOrder voucherOrder) 
    Long userId = voucherOrder.getUserId();//由于多线程,所以不能直接去ThreadLocal取
    //创建锁对象
    //SimpleRedisLock lock = new SimpleRedisLock("order:" + userId,stringRedisTemplate);
    RLock lock = redissonClient.getLock("lock:order:" + userId);
    //获取锁
    boolean hasLock = lock.tryLock( );
    if(!hasLock)
        //获取锁失败
        log.error("不允许重复下单!");
        return;
    

    try 
        //代理对象改成全局变量
        proxy.createVoucherOrder(voucherOrder);//默认是this,我们要实现事务需要proxy
     catch (IllegalStateException e) 
        throw new RuntimeException(e);
     finally 
        lock.unlock();
    



@Transactional
public void createVoucherOrder(VoucherOrder voucherOrder)
    //查询订单看看是否存在
    Long userId = UserHolder.getUser().getId();

    if (query().eq("user_id",userId).eq("voucher_id", voucherOrder.getUserId()).count()>0) 
        log.error("用户已经购买过一次!");
        return;
    

    //4.扣减库存
    boolean success = seckillVoucherService.update()
            .setSql("stock = stock -1")
            .eq("voucher_id", voucherOrder.getVoucherId()).gt("stock",0)//where id = ? and stock >0 添加了乐观锁
            .update();

    if(!success)
        log.error("优惠券库存不足!");
        return;
    

    //7.订单写入数据库
    save(voucherOrder);

 

以上是关于Redis之秒杀下单优化以及认识redis消息队列的主要内容,如果未能解决你的问题,请参考以下文章

Redis基于(ListPubSubStream消费者组)实现消息队列,基于Stream结构实现异步秒杀下单

Redis进阶学习04---秒杀优化和消息队列

秒杀——接口优化

Redis之消息队列实现

SpringBoot+RabbitMQ+Redis实现商品秒杀

Redis的优惠券秒杀问题之全局唯一ID秒杀下单超卖问题一人一单问题以及集群下的问题