黑马点评项目学习笔记--（6）消息队列

1.引言

前面我们知道了基于阻塞队列的异步秒杀实际上存在两个问题，一个是 JVM 的内存限制，一个是阻塞队列中的数据可能面临服务宕机的数据丢失问题。

为了解决这个问题，我们将引入消息队列

2.消息队列

消息队列，顾名思义就是存放消息的队列，常见的消息队列模型包括三个角色：

• 消息队列（消息代理）：存储和管理消息
• 生产者：发送消息到消息队列
• 消费者：从消息队列中取消息并处理

redis实现消息队列的三种方法：

• list 结构：基于 List 结构模拟消息队列
• PubSub：基本的点对点消息模型
• Stream： 比较完善的消息队列模型

3.基于List的消息队列

通过 List 的 BLPUSH 和 BRPOP 或者 BRPUSH 和 BLPOP 来实现类似JVM阻塞队列的效果

优缺点

优点：

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

缺点：

• 无法避免消息丢失

一个消息可能从阻塞队列拿出后还没来得及处理，服务就宕机了，造成消息丢失

• 只支持单消费者

虽然我们这个业务不需要这个特点，但是有些业务是需要做到一个消息可以被多个消费者使用的

4.基于PubSub的消息队列

redis中有发布 pubscribe 和 订阅 subscribe 的功能，通过向频道发送消息和从某个频道接收消息，可以实现一条消息被多个消费者使用的情况。而且subscribe命令本身是阻塞式的，没有收到消息是阻塞状态，收到消息后显示在客户端后还是处于阻塞状态。

因此，它与基于List的消息队列的单消费者特点不一样

优缺点

优点：

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

缺点：

• 不支持数据持久化
• 无法避免消息丢失

如果生产者向一个频道发送消息时，没有订阅该频道的消费者，就会丢失这条消息

• 消息堆积有上限，超出时数据丢失

消费者获得消息后，会将消息放在消费者的缓冲区中，而缓冲区是有上限的。

5.基于Stream的消息队列

Stream是Redis5.0引入的一种消息队列，可以实现一个功能非常完善的消息队列
发送消息的命令：xadd

接收消息的命令：xread

Stream可能出现的问题–消息漏读

当我们xread指定读取的消息起始id为$也就是最新消息时，当一条消息读取到后，一直到下一次 xread 操作的过程中，那些发送过来的消息，只要不是最后一条消息，都会被漏读

优缺点

优点：

• 消息可回溯

一条消息可以被多次读取

• 一个消息可以被多个消费者读取
• 可以阻塞读取

缺点:

• 有消息漏读的风险

6.Stream的消费组模式

特点

• 消息分流

队列中的消息会分流给组内的不同消费者，在一个组中，不会出现一条消息被多个消费者消费的情况，从而加快消息处理的速度。

• 消息标示

消费者组会维护一个标示，记录最后一个被处理的消息，哪怕消费者宕机重启，还会从标示之后读取消息。确保每一个消息都会被消费。这个消息标示也避免了消息漏读。

• 消息确认

消费者获取消息后，消息会处于 pending 待定状态，并存入一个 pending-list 中。当消息被处理完成后，需要通过 xack 来确认消息，这样，消息才会被标记为已处理，然后从 pending-list 中移除。

Stream消费者组模式相关命令

创建消费者组：

其它常见命令：

消费者其实一般不需要我们收到创建和删除，redis 会帮我们完成

从消费者组中读取消息：

每个被消费的消息都会被标示，起始 ID 若是 > 可以根据标示找到下一个未消费的消息

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

消费者不断从Stream消息队列中取出还未被消费的消息，没有取到就进入下一次循环再次获取消息，取到消息之后，处理消息，处理消息完成后会进行ack，如果在处理消息的过程中出现异常，那么进入catch代码块中，对pending-list中的消息进行处理（也会ack），这个时候如果处理过程还是报异常，会记录日志，必要时进行人工介入，同时会进入下一次循环，直到从pending-list中取不出消息。

Stream类型消息队列的xreadgroup命令的特点：

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

7.对比三种消息队列的实现

	List	PubSub	Stream
消息持久化	支持	不支持	支持
阻塞读取	支持	支持	支持
消息堆积处理	受限于内存空间，可以利用多消费者加快处理（注意这里和List的单消费者模式不是一回事，单消费者模式是指一个消息只能被一个消费者取，取走了消息队列中就没有这个消息了,这里是说List实现的消息队列可以有多个消费者来消费）	受限于消费者缓冲区	受限于队列长度，可以利用消费者组加快消费速度，减少堆积
消息确认机制	不支持	不支持	支持
消息回溯	不支持	不支持	支持

8.基于Stream消息队列实现异步秒杀

1)创建stream类型的消息队列

这里将消费者组和消息队列一起创建

2）修改之前的秒杀下单Lua脚本，在认定有抢购资格后，直接向stream.orders中添加消息，内容包括voucherId、userId、orderId

这样一来，可以减少java代码和redis的交互，提升了效率

3）项目启动时，开启一个线程任务，尝试获取stream.orders中的消息，完成下单

完整代码：

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

    @Resource
    private ISeckillVoucherService seckillVoucherService;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Resource
    private RedissonClient redissonClient;

    @Resource
    private RedisIdWorker redisIdWorker;

    //在类加载的时候就将脚本读取好Lua脚本方便直接使用
    private static final DefaultRedisScript<Long> SECKILL_SCRIPT;
    static {
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
        SECKILL_SCRIPT.setResultType(Long.class);
    }

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

    //PostConstruct注解的方法在所在类初始化的时候执行
    @PostConstruct
    private void init(){
        SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    }
    private class VoucherOrderHandler implements Runnable{
    String queueName = "stream.orders";
        @Override
        public void run() {
            while(true){
                try {
                    //1.获取消息队列中的订单消息 XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS streams.order >
                    List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                            Consumer.from("g1", "c1"),
                            StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
                            StreamOffset.create(queueName, ReadOffset.lastConsumed())
                    );
                    //2.判断消息获取是否成功
                    if (list == null || list.isEmpty()) {
                        //2.1如果获取失败，说明没有消息，继续下一次循环
                        continue;
                    }
                    //3.解析消息中的订单信息
                    //这里Map中的String是消息的id
                    MapRecord<String, Object, Object> record = list.get(0);
                    Map<Object, Object> values = record.getValue();
                    VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(values, new VoucherOrder(), true);
                    //4.如果获取成功，可以下单
                    handleVoucherOrder(voucherOrder);
                    //5.ACK确认 SACK stream.orders g1 id
                    stringRedisTemplate.opsForStream().acknowledge(queueName,"g1",record.getId());
                } catch (Exception e) {
                    log.error("处理订单异常",e);
                    handlePendingList();
                }
            }
        }

        private void handlePendingList() {
            while(true){
                try {
                    //1.获取pending-list中的订单消息 XREADGROUP GROUP g1 c1 COUNT 1 STREAMS streams.order 0
                    List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                            Consumer.from("g1", "c1"),
                            StreamReadOptions.empty().count(1),
                            StreamOffset.create(queueName, ReadOffset.from("0"))
                    );
                    //2.判断消息获取是否成功
                    if (list == null || list.isEmpty()) {
                        //2.1如果获取失败，说明没有消息，结束循环
                        break;
                    }
                    //3.解析消息中的订单信息
                    //这里Map中的String是消息的id
                    MapRecord<String, Object, Object> record = list.get(0);
                    Map<Object, Object> values = record.getValue();
                    VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(values, new VoucherOrder(), true);
                    //4.如果获取成功，可以下单
                    handleVoucherOrder(voucherOrder);
                    //5.ACK确认 SACK stream.orders g1 id
                    stringRedisTemplate.opsForStream().acknowledge(queueName,"g1",record.getId());
                } catch (Exception e) {
                    log.error("处理订单异常",e);
                    //避免频繁抛出异常，休眠一下
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException interruptedException) {
                        interruptedException.printStackTrace();
                    }
                }
            }
        }
    }

    private void handleVoucherOrder(VoucherOrder voucherOrder) {
        //获取用户id
        Long userId = voucherOrder.getUserId();
        //创建锁对象
        RLock lock = redissonClient.getLock("lock:order:" + userId);
        //获取锁
        boolean isLock = lock.tryLock();
        if(!isLock){
            //获取锁失败，返回错误或者重试
            log.error("不允许重复下单");
        }
        try {
            proxy.createVoucherOrder(voucherOrder);
        }finally {
            //释放锁
            lock.unlock();
        }
    }

    private IVoucherOrderService proxy;

    @Override
    public Result seckillVoucher(Long voucherId) throws InterruptedException {
        //获取用户
        Long userId = UserHolder.getUser().getId();
        //获取订单id
        //redisIdWorker可以帮助生成id
        long orderId = redisIdWorker.nextId("order");

        //1.执行lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString(),String.valueOf(orderId)
        );
        //2.判断结果是否为0
        int r = result.intValue();
        if (r != 0) {
            //2.1不为0，代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不可重复下单");
        }
        //3.获取代理对象
        proxy = (IVoucherOrderService) AopContext.currentProxy();
        //4.返回订单id
        return Result.ok(orderId);
    }

    @Transactional
    public void createVoucherOrder(VoucherOrder voucherOrder) {
        Long userId = voucherOrder.getUserId();
        Long voucherId = voucherOrder.getVoucherId();
        // 创建锁对象
        RLock redisLock = redissonClient.getLock("lock:order:" + userId);
        // 尝试获取锁
        boolean isLock = redisLock.tryLock();
        // 判断
        if (!isLock) {
            // 获取锁失败，直接返回失败或者重试
            log.error("不允许重复下单！");
            return;
        }

        try {
            // 5.1.查询订单
            int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
            // 5.2.判断是否存在
            if (count > 0) {
                // 用户已经购买过了
                log.error("不允许重复下单！");
                return;
            }

            // 6.扣减库存
            boolean success = seckillVoucherService.update()
                    .setSql("stock = stock - 1") // set stock = stock - 1
                    .eq("voucher_id", voucherId).gt("stock", 0) // where id = ? and stock > 0
                    .update();
            if (!success) {
                // 扣减失败
                log.error("库存不足！");
                return;
            }

            // 7.创建订单
            save(voucherOrder);
        } finally {
            // 释放锁
            redisLock.unlock();
        }
    }
}

异常：按照视频测试时，jemter中异常100%？？？