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

Posted 2023-01-09 爱上口袋的天空

目录

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

二、秒杀优化 - 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);