Redis实战案例21-消息队列

1. 基于JVM的阻塞队列的局限

  1. JVM内存限制问题,大量订单出现时,可能会超过JVM阻塞队列上限;
  2. 阻塞队列并不能持久化,因为内存不能持久化,出现异常或者宕机之类的故障时,出现数据丢失;

所以引出消息队列的概念

消息队列的两个优点:

  1. 消息队列在JVM以外的独立服务,不受JVM的内存限制;
  2. 消息队列不仅仅做数据存储,确保数据安全,会做数据的持久化,并且消费者取数据要做消息确认;如果没有确认,那么消息会在队列中依旧存在,下一次会再投递给消费者,让它继续处理,直到确认为止,确保消息至少消费一次;

Redis实战案例21-消息队列_第1张图片

Redis实战案例21-消息队列_第2张图片

2. 基于List结构模拟消息队列

Redis实战案例21-消息队列_第3张图片

  1. 假设从队列里取到消息,取到还未处理就发生了异常,这是消息就无法处理了,因为pop相当于remove;
  2. 发送消息,一旦被消费者拿走之后,别的消费者就无法获得了,无法解决一条消息多个消费者使用;

Redis实战案例21-消息队列_第4张图片

3. 基于PubSub的消息队列(不建议使用)

Redis实战案例21-消息队列_第5张图片

PSUBSCRIBE 订阅的格式匹配的三种规则

Redis实战案例21-消息队列_第6张图片
Redis实战案例21-消息队列_第7张图片

PubSub消息队列在传递消息时并不会将消息持久化到硬盘上,而是将消息存储在内存中,当服务重启或者发生故障时,可能会导致消息丢失。

Redis实战案例21-消息队列_第8张图片

4. 基于Stream的消息队列

Redis实战案例21-消息队列_第9张图片
Redis实战案例21-消息队列_第10张图片

$:返回最新的消息,前提是该条信息并没有被消费者读过,否则就是返回nil

Redis实战案例21-消息队列_第11张图片

阻塞等待读取最新的消息,阻塞时间设置为0表示永久等待直到有新等待消息

Redis实战案例21-消息队列_第12张图片

Redis实战案例21-消息队列_第13张图片

重点:这种读取方式存在着弊端,当指定其实ID为$时,代表读取最新等待消息,此时处理一条消息的过程中,又来了一条以上的信息到队列,则下次获取也只能获取最新的一条,可能就会出现漏读消息的问题;

当消费者读取一次之后,再生产k4、k5,此时消费者再次阻塞读取最新的消息,再生产消息k6,此时消费者只能获取消息k6,出现了消息漏读;
Redis实战案例21-消息队列_第14张图片

5. 基于Stream的消息队列问题优化

Redis实战案例21-消息队列_第15张图片
Redis实战案例21-消息队列_第16张图片
Redis实战案例21-消息队列_第17张图片
示例:

Redis实战案例21-消息队列_第18张图片
消息确认(k1…k5都在pending-list中等待确认)、

Redis实战案例21-消息队列_第19张图片
查看pending-list中所有未确认的元素

Redis实战案例21-消息队列_第20张图片
从pendin-list确认未确认的消息,此时消息的起始ID为0

Redis实战案例21-消息队列_第21张图片

所以可以得出处理消息的大致流程:先利用>的方式去获取所有未消费的消息,然后确认,如果出现异常,在Java中catch采用0的方法去获取pending-list的消息(异常消息),处理完毕再确认,pending-list清空;之后再使用>的方式继续获取未消费的消息,直到阻塞时间过后返回为nil;

Redis实战案例21-消息队列_第22张图片

6. 基于Redis的Stream结构实现异步秒杀

Redis实战案例21-消息队列_第23张图片

创建消息队列

在这里插入图片描述

修改lua脚本,认定可以抢购直接发送消息到消息队列中

注意

如果 redis.call('get', stockKey) 返回的结果是空值(nil),那么尝试将空值转换为数字时会出现错误。
因为无法将空值转换为数字。
为了避免这种错误,可以在进行比较之前,先检查返回结果是否为非空值。
这样,如果 redis.call('get', stockKey) 返回的结果是空值,就不会进行比较,从而避免了错误。

-- 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 判断库存是否充足
local stock = redis.call('get', stockKey)
if stock and tonumber(stock) <= 0 then
    -- 3.2 库存不足 返回1
    return 1
end
-- 3.2 判断用户是否下单
if(redis.call('sismember', orderKey, userId) == 1) then
    -- 3.3 存在,说明是重复下单,返回2
    return 2
end
-- 3.4 扣库存
redis.call('incrby', stockKey, -1)
-- 3.5 下单(保存用户)
redis.call('sadd', orderKey, userId)
-- 3.6 发送消息到队列中,XDD stream.orders * k1 v1 k2 v2...
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)

return 0

秒杀的逻辑修改(修改之前的阻塞队列方法)

@Override
public Result seckillVoucher(Long voucherId) {
    // 获取用户id
    Long userId = UserHolder.getUser().getId();
    // 订单id(生成唯一ID)
    long orderId = redisIdWorker.nextId("order");
    //1. 执行lua脚本(判断购买资格,发送订单信息到消息队列)
    Long result = stringRedisTemplate.execute(
            SECKILL_SCRIPT,
            Collections.emptyList(),// key参数为0,所以参数传空集合
            voucherId.toString(),
            userId.toString(),
            String.valueOf(orderId)
    );
    //2. 判断是否为0
    int i = result.intValue();
    if(i != 0) {
        //2.1 不为0,没有购买资格
        return Result.fail(i == 1 ? "库存不足" : "不能重复下单");
    }
    //3. 获取代理对象
    proxy = (IVoucherOrderService) AopContext.currentProxy();
    //4. 返回订单id
    return Result.ok(0);
}

开启线程任务

/**
 * 异步线程,从消息队列中取出订单信息,执行保存订单到数据库
 */
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 stream.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. 解析消息中的订单信息,键值类型参考脚本中的'userId', userId, 'voucherId', voucherId, 'id', orderId
                // 前者String指的是消息ID, 指的是上述键值对
                MapRecord<String, Object, Object> record = list.get(0);
                Map<Object, Object> values = record.getValue();
                // 3.1 转为voucherOrder对象
                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();
            }
        }
    }
    /**
     * 订单异常消息。采用0的方法去处理pending-list中的消息,进行ACK确认
     */
    private void handlePendingList() {
        while (true){
            try {
                // 1. 获取消息队列中的订单信息
                // XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS stream.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 如果获取失败,说明pending-list没有异常消息,继续下一次循环
                    break;
                }
                // 3. 解析消息中的订单信息,键值类型参考脚本中的'userId', userId, 'voucherId', voucherId, 'id', orderId
                // 前者String指的是消息ID, 指的是上述键值对
                MapRecord<String, Object, Object> record = list.get(0);
                Map<Object, Object> values = record.getValue();
                // 3.1 转为voucherOrder对象
                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 ex) {
                    throw new RuntimeException(ex);
                }
            }
        }
    }
}

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