Redis秒杀优化（案例：黑马点评）

今天你写代码了吗？？

已于 2023-07-08 19:32:01 修改

阅读量108

点赞数

分类专栏：黑马点评 Redis 文章标签： redis 数据库缓存

于 2023-07-08 19:28:58 首次发布

本文链接：https://blog.csdn.net/weixin_45618869/article/details/131612297

版权

Redis 同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

黑马点评

10 篇文章 0 订阅

订阅专栏

秒杀优化-异步秒杀思路(提升性能）

当用户发起请求，此时会请求nginx，nginx会访问到tomcat，而tomcat中的程序，会进行串行操作，分成如下几个步骤

1、查询优惠卷
2、判断秒杀库存是否足够
3、查询订单
4、校验是否是一人一单
5、扣减库存
6、创建订单

在这六步操作中，又有很多操作是要去操作数据库的，而且还是一个线程串行执行，这样就会导致我们的程序执行的很慢，所以我们需要异步程序执行，那么如何加速呢？
在这里插入图片描述
解决方案：
我们将耗时比较短的逻辑判断放入到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封装后存入阻塞队列
开启线程任务，不断从阻塞队列中获取信息，实现异步下单功能

新增秒杀优惠券的同时，将优惠券信息保存到Redis中
n/92ca9c1f419f4616b9dbb62aab359755.png)

    @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当中(优惠券id  和   优惠券库存）  方便进行优惠券扣减的资格判定
        stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY+voucher.getId(),voucher.getStock().toString());

    }

基于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)
-- 3.6.发送消息到队列中， XADD stream.orders * k1 v1 k2 v2 ...
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)
return 0

改造扣减资格判断逻辑------>lua脚本代替
在这里插入图片描述

 //提前初始化脚本，避免每次去执行脚本时单独去创建脚本对象
    private static final DefaultRedisScript<Long> SECKILL_SCRIPT;

    static {
        SECKILL_SCRIPT = new DefaultRedisScript<>();
        SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));//加载lua脚本
        SECKILL_SCRIPT.setResultType(Long.class);//设置返回值
    }
    /**
     * 使用lua脚本完成扣减资格判断
     * @param voucherId
     * @return
     */
    @Override
public Result seckillVoucher(Long voucherId) {
        //获取用户
        Long userId = UserHolder.getUser().getId();
        //生成订单id
        long orderId = redisIdWorker.nextId("order");
        // 1.执行lua脚本  判断是否满足扣减资格（看缓存里面是否有 重复订单）
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),//lua脚本里面没有代表key的参数  这里传入空参
                voucherId.toString(), userId.toString(), String.valueOf(orderId)  //根据lua脚本传入多个参数
        );
        int r = result.intValue();//将long类型转换为int  再去判断
        // 2.判断结果是否为0
        if (r != 0) {
            // 2.1.不为0 ，代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");   //r == 2 代表不能重复下单
        }
        //TODO 保存阻塞队列  待完成
        
        // 3.返回订单id
        return Result.ok(orderId);
}

抢购成功，将优惠券id和用户id封装后存入阻塞队列，然后开启线程池去阻塞队列里拿东西执行

1、创建阻塞队列，将 voucherOrder 对象放到队列当中

    /**
     * 初始化阻塞队列
     */
    private BlockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024*1024);

//TODO 保存阻塞队列  待完成
        VoucherOrder voucherOrder = new VoucherOrder();
        // 2.3.订单id
        voucherOrder.setId(orderId);
        // 2.4.用户id
        voucherOrder.setUserId(userId);
        // 2.5.代金券id
        voucherOrder.setVoucherId(voucherId);
        // 2.6.放入阻塞队列
        orderTasks.add(voucherOrder);

2、设置异步处理线程池，项目一启动就初始化秒杀业务类

/**
     * 异步处理线程池
     */
    private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();
 /**
     * 定义全局代理对象  使得在子线程里面也能拿到代理对象
     */
    private IVoucherOrderService proxy;
     /**
     * 在类初始化之后执行，因为当这个类初始化好了之后，随时都是有可能要执行的
     */
    @PostConstruct
    private void init() {
        SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    }
   /**
     * 用于线程池处理的任务
     * 当初始化完毕后，就会去从对列中去拿信息
     */
    private class VoucherOrderHandler implements Runnable {

        @Override
        public void run() {
            while (true) {
                try {
                    // 1.获取队列中的订单信息
                    VoucherOrder voucherOrder = orderTasks.take();
                    // 2.创建订单
                    handleVoucherOrder(voucherOrder);//创建订单 单独封装方法
                } catch (Exception e) {
                    log.error("处理订单异常", e);
                }
            }
        }
    }

/**
     * 异步处理  不用return给前端
     * @param voucherOrder
     */
    private void handleVoucherOrder(VoucherOrder voucherOrder) {
        //1.获取用户
        Long userId = voucherOrder.getUserId();//是基于一个子线程去做的  所拿到的线程是获取不到用户的id 的
        // 2.创建锁对象
        RLock redisLock = redissonClient.getLock("lock:order:" + userId);
        // 3.尝试获取锁
        boolean isLock = redisLock.tryLock();
        // 4.判断是否获得锁成功
        if (!isLock) {
            // 获取锁失败，直接返回失败或者重试
            log.error("不允许重复下单！");
            return;
        }
        try {
            //注意：由于是spring的事务是放在threadLocal中，此时的是多线程，事务会失效
            proxy.createVoucherOrder(voucherOrder);
        } finally {
            // 释放锁
            redisLock.unlock();
        }
    }
 /**
     * 将订单数据写入数据库的操作交给子线程调用
     * @param 
     */
    @Transactional
    public void createVoucherOrder(VoucherOrder voucherOrder) {
        Long userId = voucherOrder.getUserId();
        // 5.1.查询订单
        int count = query().eq("user_id", userId).eq("voucher_id", voucherOrder.getVoucherId()).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", voucherOrder.getVoucherId()).gt("stock", 0) // where id = ? and stock > 0
                .update();
        if (!success) {
            // 扣减失败
            log.error("库存不足");
            return;
        }
        save(voucherOrder);
    }
  /**
     * 使用lua脚本完成扣减资格判断
     * 并且创建订单
     * 把订单放到一个阻塞队列里面
     * 用一个子线程去完成将订单数据插入的数据库
     * @param voucherId
     * @return
     */
    @Override
    public Result seckillVoucher(Long voucherId) {
        //获取用户
        Long userId = UserHolder.getUser().getId();
        //生成订单id
        long orderId = redisIdWorker.nextId("order");
        // 1.执行lua脚本  判断是否满足扣减资格（看缓存里面是否有 重复订单）
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),//lua脚本里面没有代表key的参数  这里传入空参
                voucherId.toString(), userId.toString(), String.valueOf(orderId)  //根据lua脚本传入多个参数
        );
        int r = result.intValue();//将long类型转换为int  再去判断
        // 2.判断结果是否为0
        if (r != 0) {
            // 2.1.不为0 ，代表没有购买资格
            return Result.fail(r == 1 ? "库存不足" : "不能重复下单");   //r == 2 代表不能重复下单
        }
        //TODO 保存阻塞队列
        VoucherOrder voucherOrder = new VoucherOrder();
        // 2.3.订单id
        voucherOrder.setId(orderId);
        // 2.4.用户id
        voucherOrder.setUserId(userId);
        // 2.5.代金券id
        voucherOrder.setVoucherId(voucherId);
        // 2.6.放入阻塞队列
        orderTasks.add(voucherOrder);
        // 3.返回订单id
        //3.获取代理对象  //在主线程里面提前把代理对象拿到
        proxy = (IVoucherOrderService) AopContext.currentProxy();

        return Result.ok(orderId);
    }

注意，在handleVoucherOrder异步线程中，通过线程是拿不到用户id的，因为这执行线程池里面的一个子线程，子线程只能拿到封装在voucherOrder对象中的id（也就是主线程拿到的id）。

并且在获取代理对象时保证事务的一致性，也只能在主线程中获取代理对象，这里通过声明全局代理对象，在主线程里面提前把代理对象拿到，这样在子线程去操作数据库时才能保证事务的一致性。

 /**
     * 定义全局代理对象  使得在子线程里面也能拿到代理对象
     */
        private IVoucherOrderService proxy;


  //3.获取代理对象  //在主线程里面提前把代理对象拿到
        proxy = (IVoucherOrderService) AopContext.currentProxy();

思路

秒杀业务的优化思路是什么？

先利用Redis完成库存余量、一人一单判断，完成抢单业务
再将下单业务放入阻塞队列，利用独立线程异步下单
基于阻塞队列的异步秒杀存在哪些问题？
- 内存限制问题
- 数据安全问题

今天你写代码了吗？？

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Redis秒杀优化（案例：黑马点评）

我们将耗时比较短的逻辑判断放入到redis中，比如是否库存足够，比如是否一人一单，这样的操作，只要这种逻辑可以完成，就意味着我们是一定可以下单完成的，我们只需要进行快速的逻辑判断，根本就不用等下单逻辑走完，我们直接给用户返回成功，再在后台开一个线程，后台线程慢慢的去执行queue里边的消息，这样程序不就超级快了吗？在这六步操作中，又有很多操作是要去操作数据库的，而且还是一个线程串行执行，这样就会导致我们的程序执行的很慢，所以我们需要异步程序执行，那么如何加速呢？2、判断秒杀库存是否足够。
复制链接

扫一扫