【小众点评项目】开发日记 DAY 04 异步秒杀下单

最新推荐文章于 2024-04-18 09:09:59 发布

lyx7762

最新推荐文章于 2024-04-18 09:09:59 发布

阅读量338

点赞数

分类专栏： Redis 文章标签：数据库 java redis

本文链接：https://blog.csdn.net/lyx7762/article/details/128139409

版权

Redis 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1 异步秒杀思路

1.1 之前秒杀系统存在的问题

1.1.1 秒杀业务的流程

查询优惠卷
判断秒杀库存是否足够
查询订单
校验是否是一人一单
扣减库存
创建订单

1.1.2 问题分析

我们可以看到，在业务流程中有很多步骤是需要操作数据库的，并且一个线程还是串行执行的。肯定执行效率不高。我们可以借助饭店里面前台点餐和后厨做饭的形式来修改我们的代码。
饭店有负责点餐的服务员，他们的指责是收集顾客的点菜，然后把点菜信息给后厨即可。后厨根据排队，一个菜一个菜的做就可以了。

1.2 改造方案

首先我们把下单业务拆分成两个独立的业务。

第一个业务时根据用户id和优惠券id判断库存是否充足和用户是否已经下过单了。只要满足这两个条件，就给用户下单，并将下单信息保存到队列中。注意，此时我们只是判断了用户是否可以下单，并没有真正将订单信息写入数据库。
第二个业务是从队列中一次读取一条订单信息并写入到数据库中。

1.3 具体思路

首先秒杀优惠券这种热点数据应该提前存入redis中。

首先需要存储一个String类型的数据，key为优惠券id，值为库存量
然后存储一个Set，key为优惠券id（具体key肯定需要加各种前缀），值为一个set的列表，每一个元素存储一个下单用户的id，使用set可以保证用户是否下过单，使用redis的ismember就可以判断。
用户下单，首先判断库存是否充足，如果不充足直接返回。如果充足，那么就执行减库存，并向set中添加用户下单的id。为了保证原子性，需要使用lua脚本。
Java代码中根据lua脚本执行的返回值来判断是否下单成功，如果下单成功则创建订单，把订单加入到阻塞队列中。等待一个专门处理阻塞队列的进程将这些订单信息写入数据库。

2.异步秒杀V1.0 – 实现Lua脚本和相关代码的改造

2.1 实现添加秒杀优惠券到数据库的同时也向redis中添加一份

VoucherServiceImpl

// 只需要添加这一行代码即可
stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());

2.2 Lua脚本的编写

在这里插入图片描述

-- 1.参数
-- 优惠券ID
local voucherId = ARGV[1]
-- 用户ID
local userId = ARGV[2]

-- 2.key
-- 库存
-- stockKey String类型 以优惠券作为key，以库存数值作为value
local stockKey = "seckill:stock:" .. voucherId

-- orderKey Set类型，以优惠券作为key，以购买过这个优惠券的用户ID的列表作为值
local orderKey = "seckill:order:" .. voucherId
-- 3.业务
-- 3.1 判断库存是否充足
if (tonumber(redis.call('get', stockKey)) <= 0) then
    -- 库存不足
    return 1
end
-- 3.2 判断用户是否已经下过单
if (redis.call("sismember", orderKey, userId) == 1) then
    -- 重复下单
    return 2
end
-- 3.3 扣库存 下单
redis.call('incrby', stockKey, -1)
redis.call('sadd', orderKey, userId)

同时还需要修改
VoucherOrderServiceImpl

@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 ? "库存不足" : "不能重复下单");
    }
    // 有购买资格，创建订单
    VoucherOrder voucherOrder = new VoucherOrder();
    // 2.3.订单id
    long orderId = redisIdWorker.nextId("order");
    voucherOrder.setId(orderId);
    // 2.4.用户id
    voucherOrder.setUserId(userId);
    // 2.5.代金券id
    voucherOrder.setVoucherId(voucherId);
    
    //TODO 保存阻塞队列
    
    // 由于是spring的事务是放在threadLocal中，此时的是多线程，事务会失效
    proxy = (IVoucherOrderService)AopContext.currentProxy();    
    // 3.返回订单id
    return Result.ok(orderId);
}

为了让让lua脚本能够在类加载的时候就加载，还需要在VoucherOrderServiceImpl中添加下面的代码

private static DefaultRedisScript<Long> SECKILL_SCRIPT;
static {
    SECKILL_SCRIPT = new DefaultRedisScript<>();
    SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
    SECKILL_SCRIPT.setResultType(Long.class);
}

3.异步秒杀V1.1 – 创建阻塞队列

3.1 前情提要

在V1.0的版本中，我们已经实现了使用lua脚本来判断用户是否有购买资格。在Java代码中通过lua脚本不同的返回值来判断用户是否有购买资格。如果有购买资格则为用户创建订单。接下来要完成的步骤

创建阻塞队列
创建线程池
创建一个线程，可以持续的从阻塞队列中读取数据，并写入到数据库

3.2 代码改造

3.2.1 创建阻塞队列和线程池

private BlockingQueue<VoucherOrder> ordertasks = new ArrayBlockingQueue<>(1024 * 1024);
// 创建线程池
private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

3.2.2 创建一个线程来读取阻塞队列中的数据

//  这里我们使用了VoucherOrderServiceImpl中内部类的方式实现
private class VoucherOrderHandler implements Runnable {
    @Override
    public void run() {
        while (true) {
            // 从阻塞队列中取出订单
            try {
                VoucherOrder order = ordertasks.take();
                handlerVoucherOrder(order);
            } catch (Exception e) {
                log.error("处理订单异常", e);
            }
        }
    }
}

3.2.3 调用线程池执行我们创建的线程任务

这里我们采用了init方法来提交我们的线程任务，使用@PostConstruct的作用是让这个类加载完成后就开始让线程一直监听阻塞队列中的订单。

@PostConstruct
private void init() {
    SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    // 使用消息队列实现秒杀 由于Windows版本的Redis没有Stream队列 因此这里我们还是使用之前的基于阻塞队列的方式实现秒杀
    // SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandlerWithMQ());
}

3.2.4 需要注意的问题

由于这里我们是开启了新的线程来执行，因此用户id就不能从ThreadLocal中获取了，此外AopContext.currentProxy();方法也是从ThreadLocal中获取当前类的代理类对象，因此也失效了。因此需要修改代码。

// 保存到类的成员变量
IVoucherOrderService proxy = (IVoucherOrderService)AopContext.currentProxy();
private void handlerVoucherOrder(VoucherOrder order) {
     ..........
    try {
        // 将订单保存到数据库
        proxy.saleVoucher(order);
    } finally {
        lock.unlock();
    }
}

4.思路总结

首先利用lua脚本结合redis完成购买资格的认证。
Java中根据lua脚本的返回值确定是否需要创建订单，如果需要则创建并加入到阻塞队列
创建独立线程监听阻塞队列，一旦有订单就写入数据库。

缺点

阻塞队列是基于JVM内存的，高并发状态下可能会产生JVM内存溢出问题。
阻塞队列是基于内存的，一旦出现故障，则内容全部丢失。

5.Redis消息队列

5.1 消息队列的定义

消息队列顾名思义就是存放消息的队列，主要包含一下三个角色

生产者，发送消息到消息队列
消息队列，存储消息
消费者，从消息队列中取消息。

消息队列的好处在于解耦。最简单的例子生活中取快递的例子。消息队列就相当于菜鸟驿站。快递员就相当于生产者，快递员(生产者)把快递放到快递柜里边(Message Queue)去，我们(消费者)从快递柜里边去拿东西，这就是一个异步，两者之间没有耦合。但是如果去掉菜鸟驿站，让快递员亲手交给我，那么如果我不在家，那么快递员就只能等待，这就浪费了大量的时间，耦合性高。

5.2 改造思路

Reids中为我们提供了几种数据结构可以帮助我们实现消息队列。利用redis去进行校验下单条件，再通过队列把消息发送出去，然后再启动一个线程去消费这个消息，完成解耦，同时也加快我们的响应速度。
我们可以使用Lua脚本，直接在脚本里面判断用户是否有资格购买，如果有资格购买，直接在Lua脚本中向redis中的消息队列中添加订单信息即可。

5.3 List实现消息队列

消息队列（Message Queue），字面意思就是存放消息的队列。而Redis的list数据结构是一个双向链表，很容易模拟出队列效果。
队列是入口和出口不在一边，因此我们可以利用：LPUSH 结合 RPOP、或者 RPUSH 结合 LPOP来实现。不过要注意的是，当队列中没有消息时RPOP或LPOP操作会返回null，并不像JVM的阻塞队列那样会阻塞并等待消息。因此这里应该使用BRPOP或者BLPOP来实现阻塞效果。
在这里插入图片描述
使用list实现的消息队列的优缺点

利用Redis存储，不在局限于JVM内存到限制
Redis提供了持久化机制，数据安全有保证
满足消息的有序性
无法避免消息丢失
只支持单消费者

5.4 基于PubSub的消息队列

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

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

优点：一个队列可以有多个消费者和多个生产者。
缺点
不支持数据的持久化，因为不是redis的一种数据类型
无法避免消息的丢失。生产者发送一个消息，如果此时没有消费者接受，那么消息自动丢弃。
消息堆积有上线，并且消息是缓存在客户端的。

5.5 基于Stream的消息队列

具体用法略。
使用Stream方式作为消息队列的业务流程
在这里插入图片描述
基于Stream的消息队列的特点

消息可以持久化
可以有多个消费者同时消费，加快消费速度
可以阻塞读取
不会有漏读消息的风险。消费者组会维护一个标识来记录最后一个被处理过的消息，即使消费者宕机，也会从标识之后读取信息，确保不会漏读。
有消息确认机制。消息被处理后会进入pendingList，等待消费者处理完后发送ACK确认，消息才从pendList中移除。

5.6 基于Stream消息队列改造代码

5.6.1 修改Lua脚本，在lua脚本最后追加下面代码，在redis中创建一个消息队列，名为tream.orders

-- 3.3 将订单信息保存到消息队列中
redis.call('XADD', 'steam.orders', '*', 'userId', userId, 'voucherId', voucherId, "id", orderId)
return 0

读取lua脚本

private static DefaultRedisScript<Long> SECKILL_SCRIPT_WITH_MQ;

static {
    SECKILL_SCRIPT_WITH_MQ = new DefaultRedisScript<>();
    SECKILL_SCRIPT_WITH_MQ.setLocation(new ClassPathResource("seckillWithMQ.lua"));
    SECKILL_SCRIPT_WITH_MQ.setResultType(Long.class);
}

5.6.2 修改线程任务

private class VoucherOrderHandlerWithMQ implements Runnable {
    String queueName = "stream.orders";

    /**
     * 负责一直从消息队列中取消息
     */
    @Override
    public void run() {
        while (true) {
            try {
                // 1.从消息队列中一条消息 XREADGROUP g1 c1 Count 1 block 2000 STREAMS stream.orders >
                // 返回list原因是可能一次读取多个消息
                List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                        Consumer.from("g1", "c1"),
                        StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
                        // ReadOffset.lastConsumed代表 >
                        StreamOffset.create(queueName, ReadOffset.lastConsumed())
                );
                // 2.判断消息是否获取成功
                if (list == null || list.isEmpty()) {
                    // 当前无消息 继续循环
                    continue;
                }
                // 3.执行下单业务
                // 解析消息 封装成对象
                MapRecord<String, Object, Object> record = list.get(0);
                // 获取键值对 这个就是我们保存的对象
                Map<Object, Object> value = record.getValue();
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
                // 下单 将结果保存到数据库
                handlerVoucherOrder(voucherOrder);
                // 4.发送ACK确认消息
                stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", record.getId());
            } catch (Exception e) {
                log.error("处理订单异常");
                handPendingList();
            }
        }
    }

    private void handPendingList() {
        while (true) {
            try {
                // 1.从消息队列的pendingList中一条消息 XREADGROUP g1 c1 Count 1  STREAMS stream.orders 0
                // 返回list原因是可能一次读取多个消息
                List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                        Consumer.from("g1", "c1"),
                        StreamReadOptions.empty().count(1),
                        // ReadOffset.lastConsumed代表 >
                        StreamOffset.create(queueName, ReadOffset.from("0"))
                );
                // 2.判断消息是否获取成功
                if (list == null || list.isEmpty()) {
                    // pending-List中没有消息，那么所有消息都已经正常接收 退出当前循环
                    break;
                }
                // 3.执行下单业务
                // 解析消息 封装成对象
                MapRecord<String, Object, Object> record = list.get(0);
                // 获取键值对 这个就是我们保存的对象
                Map<Object, Object> value = record.getValue();
                VoucherOrder voucherOrder = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
                // 下单 将结果保存到数据库
                handlerVoucherOrder(voucherOrder);
                // 4.发送ACK确认消息
                stringRedisTemplate.opsForStream().acknowledge(queueName, "g1", record.getId());
            } catch (Exception e) {
                try {
                    log.error("处理pendingList异常");
                    // 暂停20ms防止处理太频繁 类似于 block 2000
                    Thread.sleep(20);
                } catch (InterruptedException ex) {
                    throw new RuntimeException(ex);
                }
            }
        }
    }
}

@Override
public Result seckillVoucherWithMQ(Long voucherId) {
    Long orderId = redisIdWorker.nextId("order");
    // TODO 执行Lua脚本 脚本内容是判断购买资格 如果有资格就将订单信息保存到消息队列
    Long result = stringRedisTemplate.execute(
            SECKILL_SCRIPT,
            Collections.emptyList(),
            voucherId.toString(),
            UserHolder.getUser().getId().toString(),
            String.valueOf(orderId)
    );
    // TODO 判断结果
    // 如果不是0 返回错误信息
    int r = result.intValue();
    if (r != 0) {
        // 下单失败
        return Result.fail(r == 1 ? "库存不足" : "一个用户只能下一单");
    }
    proxy = (IVoucherOrderService) AopContext.currentProxy();
    // TODO 返回订单ID
    return Result.ok(orderId);
}