Redis实际应用3

Redis优化秒杀

原方案的问题

流程图：

存在的问题：

第一点： 这一项业务里面过多的访问了数据的，而数据库在处理并发的时候不是很行，影响性能。
第二点： 该业务一条线执行，过于繁琐。列子：你开个饭店一个店员又点餐，又做饭。很慢

解决方案

流程图

大致框图：

流程图：
对于查询的操作，我们用缓存进行存放，而为了保持原子性我们采用lua脚本进行编写。
数据结构选取set这样确保id的唯一性实现一人一单的效果。
同时采用异步处理，用户获得id先去消费。后续的处理异步进行。

需求

1：新增秒杀优惠券的同时，将优惠券信息保存到Redis中

只需要在 保存秒杀卷到 数据库的时候，顺道保存到redis即可：

2：基于Lua脚本，判断秒杀库存、一人一单，决定用户是否抢购成功

Lua的流程图：

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.判断库存是否充足 get stockKey
if(tonumber(redis.call('get', stockKey)) <= 0) then
    -- 3.2.库存不足，返回1
    return 1
end
-- 3.2.判断用户是否下单 SISMEMBER orderKey userId
if(redis.call('sismember', orderKey, userId) == 1) then
    -- 3.3.存在，说明是重复下单，返回2
    return 2
end
-- 3.4.扣库存 incrby stockKey -1
redis.call('incrby', stockKey, -1)
-- 3.5.下单（保存用户）sadd orderKey userId
redis.call('sadd', orderKey, userId)
return 0

下一步流程图： 这一步实现框住的部分

代码：

   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();
        long orderId = redisIdWorker.nextId("order");
        // 1.执行lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(), userId.toString(), String.valueOf(orderId)
        );
        int r = result.intValue();
        // 2.判断结果是否为0
        if (r != 0) {
            // 2.1.不为0 ，代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
        }
        //ToDO  阻塞队列实现插入到数据库
        // 3.返回订单id
        return Result.ok(orderId);
    }

3：如果抢购成功，将优惠券id和用户id封装后存入阻塞队列

就是 把上面的未完成的进行完成
首先第一步：
把阻塞队列创建出来

接着第二步
将优惠券id和用户id封装后存入阻塞队列

第三步：
编写队列的处理代码：

第四步：
将数据放到数据库：就是以前方法的后半段 注意使用redisson加锁。

4：开启线程任务，不断从阻塞队列中获取信息，实现异步下单功能

第一步： 需要进行异步处理的线程池创建出来创建出来：

**第二步：**开启线程：
这个是在 初始化后就开始异步处理队列的消息 将其存放到数据库之中。

总结

基于Redis的队列

消息队列的相关知识：

基于List实现（了解，不完善不推荐）

总结：

基于PubSub实现（了解，不完善不推荐）

总结

基于Stream实现（了解，不完善不推荐）

主要是 采用这两个指令（XADD，XREAD）进行的实现

基于Stream分组（推荐）

下图是用分组的形式的好处

主要是基于以下两个命令（XGROUP，XREADGROUP）：

XGROUP

XREADGROUP

实际操作：

首先存点数据到队列：
xadd 创建一个叫s1的队列

然后创建分组：
xgroup： 创建一个分组，组别叫g1 从s1的第一个消息开始发送

接着读取：
xreadgroup：

最后确认处理
xack: 我只确认了 3个 2 3 4

前面说 你如果消费了 但是没有确认的话 消息会存放在 pending-list里面
只需要最后的 > 换成 0即可

这就是 c1 c2 消费了 但是没有读取的消息。
如果要看全局的 pending-list 使用指令：官网

伪代码

实际操作

1：创建一个Stream类型的消息队列，名为stream.orders

2：修改之前的秒杀下单Lua脚本，在认定有抢购资格后，直接向stream.orders中添加消息，内容包含voucherld、userld、orderld

**lua： **只需要最后加一个这个即可

**逻辑代码：**这一段就不需要了 数据都在lua脚本中进行了执行不需要再独自进行封装了。

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

由于使用了redis队列 ，原来的阻塞队列可以注销了

 private class VoucherOrderHandler implements Runnable {

        @Override
        public void run() {
            while (true) {
                try {
                    // 1.获取消息队列中的订单信息 XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS s1 >
                    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.判断订单信息是否为空
                    if (list == null || list.isEmpty()) {
                        // 如果为null，说明没有消息，继续下一次循环
                        continue;
                    }
                    // 解析数据
                    MapRecord<String, Object, Object> record = list.get(0);
                    Map<Object, Object> value = record.getValue();
                    VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
                    // 3.创建订单
                    createVoucherOrder(voucherOrder);
                    // 4.确认消息 XACK
                    stringRedisTemplate.opsForStream().acknowledge("s1", "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 BLOCK 2000 STREAMS s1 0
                    List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                            Consumer.from("g1", "c1"),
                            StreamReadOptions.empty().count(1),
                            StreamOffset.create("stream.orders", ReadOffset.from("0"))
                    );
                    // 2.判断订单信息是否为空
                    if (list == null || list.isEmpty()) {
                        // 如果为null，说明没有异常消息，结束循环
                        break;
                    }
                    // 解析数据
                    MapRecord<String, Object, Object> record = list.get(0);
                    Map<Object, Object> value = record.getValue();
                    VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
                    // 3.创建订单
                    createVoucherOrder(voucherOrder);
                    // 4.确认消息 XACK
                    stringRedisTemplate.opsForStream().acknowledge("s1", "g1", record.getId());
                } catch (Exception e) {
                    log.error("处理订单异常", e);
                }
            }
        }
    }

总结：