【黑马点评】Day02:优惠券秒杀与分布式锁

目录

[一、全局唯一 ID](#一、全局唯一 ID)

[1.1 为什么需要全局 ID?](#1.1 为什么需要全局 ID?)

[1.2 Redis 实现全局 ID](#1.2 Redis 实现全局 ID)

二、优惠券秒杀下单

[2.1 添加优惠卷](#2.1 添加优惠卷)

[2.2 业务分析](#2.2 业务分析)

[2.3 代码实现](#2.3 代码实现)

Controller层:

Service层:

[2.4 并发订单秒杀](#2.4 并发订单秒杀)

[2.5 超卖问题解决](#2.5 超卖问题解决)

三、一人一单

[3.1 需求](#3.1 需求)

[3.2 实现思路](#3.2 实现思路)

[3.3 锁的粒度与事务陷阱](#3.3 锁的粒度与事务陷阱)

四、集群下的锁失效与分布式锁

[4.1 问题](#4.1 问题)

[4.2 分布式锁的基本要求](#4.2 分布式锁的基本要求)

[4.3 分布式锁的方式](#4.3 分布式锁的方式)

[4.4 Redis分布式锁核心思路](#4.4 Redis分布式锁核心思路)

[4.5 Redis实现分布式锁](#4.5 Redis实现分布式锁)

[4.6 Redis分布式锁误删情况](#4.6 Redis分布式锁误删情况)

[4.7 原子性问题与 Lua 脚本](#4.7 原子性问题与 Lua 脚本)

五、Redisson:生产级分布式锁

[5.1 自己实现的锁还有什么问题?](#5.1 自己实现的锁还有什么问题?)

[5.2 Redisson 快速入门](#5.2 Redisson 快速入门)

[5.3 Redisson 核心机制](#5.3 Redisson 核心机制)

六、秒杀异步优化

[6.1 为什么要异步?](#6.1 为什么要异步?)

[6.2 用 Lua 脚本完成资格判断](#6.2 用 Lua 脚本完成资格判断)

需求1:创建秒杀订单时将库存存入Redis中

需求2:基于Lua脚本,实现判断秒杀库存、一人一单功能

需求3:抢购成功后,将优惠券id和用户id封装后存入阻塞队列

需求4:开启线程任务,不断从阻塞队列中获取订单信息,实现异步下单的功能

七、认识消息队列

[7.1 什么是消息队列?](#7.1 什么是消息队列?)

[7.2 为什么需要消息队列?](#7.2 为什么需要消息队列?)

[7.3 Redis 的三种消息队列方案](#7.3 Redis 的三种消息队列方案)

[7.3.1基于 List 实现消息队列](#7.3.1基于 List 实现消息队列)

[1. 基本思路](#1. 基本思路)

[2. 优缺点](#2. 优缺点)

[7.3.2 基于 PubSub 实现消息队列](#7.3.2 基于 PubSub 实现消息队列)

[1. 基本思路](#1. 基本思路)

[2. 优缺点](#2. 优缺点)

[7.3.3 基于 Stream 实现消息队列](#7.3.3 基于 Stream 实现消息队列)

[1. Stream 是什么?](#1. Stream 是什么?)

[2. 基本命令](#2. 基本命令)

[3. XREAD 的漏读问题](#3. XREAD 的漏读问题)

[4. 消费者组(Consumer Group)](#4. 消费者组(Consumer Group))

[5. 消费者组的工作流程](#5. 消费者组的工作流程)

[6. Stream 消费者组的优势](#6. Stream 消费者组的优势)

[7.4 三种方案对比](#7.4 三种方案对比)

[7.5 实战:用 Stream 改造异步秒杀](#7.5 实战:用 Stream 改造异步秒杀)

整体思路

[第一步:创建 Stream 和消费者组](#第一步:创建 Stream 和消费者组)

[第二步:修改 Lua 脚本](#第二步:修改 Lua 脚本)

[第三步:Java 调用 Lua 脚本](#第三步:Java 调用 Lua 脚本)

第四步:后台线程消费消息

[第五步:处理 pending-list](#第五步:处理 pending-list)

订单落库(带兜底)

八、总结


在前面的课程中,我们完成了短信登录和商户缓存。今天,我们进入项目中最刺激的模块------优惠券秒杀 。秒杀业务的特点是:瞬时高并发、库存有限、一人一单 。如果不做任何处理,会出现超卖 和重复下单问题;而单机锁在集群环境下又会失效。本文将带你从全局唯一ID开始,一步步解决超卖、一人一单、集群并发问题,最终用 Redis 分布式锁和 Redisson 打造一个高性能的秒杀系统。


一、全局唯一 ID

1.1 为什么需要全局 ID?

订单表如果使用数据库自增 ID,有两个问题:

  • 规律太明显:对手可以通过订单 ID 推测你一天的销量

  • 受单表数据量限制:MySQL 单表不宜超过 500 万,分库分表后自增 ID 会重复

全局 ID 生成器需要满足:唯一、高可用、高性能、递增、安全。


常见的全局唯一ID生成策略:

  1. UUID(Java自带的)
  2. Redis自增(已实现)每天一个key,不会超出上限,且能够便于统计每天订单数量
  3. ID构造为 时间戳+计数器(序列号)
  4. snowflake算法(雪花算法,著名的ID生成算法)

数据库自增:另外用一个数据库表专门存储自增ID,而不是数据库表ID本身自增

1.2 Redis 实现全局 ID

我们不直接使用 Redis 自增数值,而是拼接:符号位(1bit)+ 时间戳(31bit)+ 序列号(32bit)。

java 复制代码
@Component
public class RedisIdWorker {
    /**
     * 开始时间戳
     */
    private static final long BEGIN_TIMESTAMP = 1640995200L;
    /**
     * 序列号的位数
     */
    private static final int COUNT_BITS = 32;

    private StringRedisTemplate stringRedisTemplate;

    public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    public long nextId(String keyPrefix) {
        // 1.生成时间戳
        LocalDateTime now = LocalDateTime.now();
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
        long timestamp = nowSecond - BEGIN_TIMESTAMP;

        // 2.生成序列号
        // 2.1.获取当前日期,精确到天
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        // 2.2.自增长
        long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);

        // 3.拼接并返回
        return timestamp << COUNT_BITS | count;
    }
}

<< 左移留出序列号位置,| 按位或拼接,保证 ID 唯一且递增。


二、优惠券秒杀下单

2.1 添加优惠卷

每个店铺都可以发布优惠券,分为平价券和特价券。平价券可以任意购买,而特价券需要秒杀抢购:

  • tb_voucher:优惠券的基本信息,优惠金额、使用规则等
  • tb_seckill_voucher:优惠券的库存、开始抢购时间,结束抢购时间。特价优惠券才需要填写这些信息

平价卷由于优惠力度并不是很大,所以是可以任意领取

而代金券由于优惠力度大,所以像第二种卷,就得限制数量,从表结构上也能看出,特价卷除了具有优惠卷的基本信息以外,还具有库存,抢购时间,结束时间等等字段

新增秒杀卷代码:

VoucherController

java 复制代码
@PostMapping("seckill")
public Result addSeckillVoucher(@RequestBody Voucher voucher) {
    voucherService.addSeckillVoucher(voucher);
    return Result.ok(voucher.getId());
}

VoucherServiceImpl

java 复制代码
@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中
    stringRedisTemplate.opsForValue().set(SECKILL_STOCK_KEY + voucher.getId(), voucher.getStock().toString());
}

测试

2.2 业务分析

秒杀下单需要判断:

  • 秒杀是否开始/结束

  • 库存是否充足

  • (后续)是否一人一单

2.3 代码实现

Controller层:
java 复制代码
@RestController
@RequestMapping("/voucher-order")
public class VoucherOrderController {
    @Autowired
    private IVoucherOrderService voucherOrderService;
    @PostMapping("seckill/{id}")
    public Result seckillVoucher(@PathVariable("id") Long voucherId) {
        return voucherOrderService.seckillVoucher(voucherId);
    }
}
Service层:
java 复制代码
@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
    @Autowired
    private SeckillVoucherServiceImpl seckillVoucherService;
    @Autowired
    private RedisIdWorker redisIdWorker;
    @Override
    public Result seckillVoucher(Long voucherId) {
        // 1. 查询优惠券信息
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        // 2. 判断秒杀活动是否开始
        if (seckillVoucher.getBeginTime().isAfter(LocalDateTime.now())) {
            return Result.fail(MessageConstant.SECKILL_IS_NOT_START);// 活动还未开始
        }
        //3. 判断秒杀活动是否结束
        if (seckillVoucher.getEndTime().isBefore(LocalDateTime.now())) {
            return Result.fail(MessageConstant.SECKILL_IS_OVER);// 秒杀已经结束
        }
        //4. 判断库存是否充足
        if (seckillVoucher.getStock() < 1) {
            return Result.fail(MessageConstant.STOCK_IS_NOT_ENOUGH);// 库存不足
        }
        // 5. 扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId)
                .update();
        if (!success) {
            // 扣减库存失败,返回错误信息
            return Result.fail(MessageConstant.STOCK_IS_NOT_ENOUGH);
        }
        // 6. 创建订单
        Long orderId = redisIdWorker.nextId("order");
        VoucherOrder voucherOrder = new VoucherOrder();
        voucherOrder.setId(orderId);// 订单Id
        voucherOrder.setUserId(UserHolder.getUser().getId());// 用户Id
        voucherOrder.setVoucherId(voucherId);// 代金券id
        save(voucherOrder);// 插入到数据库中
        // 7. 返回订单id
        return Result.ok(orderId);
    }
}

2.4 并发订单秒杀

在之前的代码中,我们只是实现了单个用户购买秒杀券的功能,但在实际应用中,秒杀券的购买是并发执行的,此时就涉及到了库存超卖的问题需要被解决。

通过jmeter进行并发测试

我们发现一百张的库存,超卖了93张,且都成功创建了订单,这是不行的。

2.5 超卖问题解决

现象:100 个库存,并发 200 个请求,最后可能卖出 193 单。

原因:多个线程同时查到库存 > 0,都执行了扣减。

解决方案:

方案 说明 适用场景
悲观锁 synchronized、Lock,串行执行 写多读少
乐观锁 版本号 / CAS,更新时判断是否被修改 读多写少

乐观锁改进:

1.版本号法

通过增加一个version 字段,每一次数据修改都进行version+1,每次数据修改都得保证version是刚查到的版本,否则就修改失败。

整体流程如下:

2.CAS法:

通过用待修改的数据(如库存值)替代版本号version,每次修改数据必须在查询到的原来数据不变的情况下才能完成。

整体流程如下:

java 复制代码
boolean success = seckillVoucherService.update()
            .setSql("stock= stock -1")
            .eq("voucher_id", voucherId)
            .gt("stock",0)
            .update(); //where id = ? and stock > 0

用 stock > 0 代替 stock = 查询时的值,避免大量线程因版本不一致而失败。

测试:


三、一人一单

3.1 需求

同一个优惠券,一个用户只能下一单。

3.2 实现思路

在扣减库存前,先查订单表:user_id + voucher_id 是否已存在。

但并发下仍然会重复,需要加锁。

java 复制代码
    @Transactional
    public Result createVoucherOrder(Long voucherId) {
        // 1.获取当前用户Id
        Long userId = UserHolder.getUser().getId();
        // 2.查询订单中是否存在当前用户和秒杀券信息
        Integer count = query().eq("user_id", userId)
                .eq("voucher_id", voucherId)
                .count();
        // 3.判断订单是否存在
        if (count > 0) {
            return Result.fail(MessageConstant.REPEAT_BUY);// 禁止重复购买
        }
        // 4. 扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId)
//                .eq("stock", seckillVoucher.getStock()) // 乐观锁,判断库存是否被修改
                .gt("stock", 0)// 剩余库存大于0才扣减库存
                .update();
        if (!success) {
            // 5扣减库存失败,返回错误信息
            return Result.fail(MessageConstant.STOCK_IS_NOT_ENOUGH);
        }
        // 6. 创建订单
        Long orderId = redisIdWorker.nextId("order");
        VoucherOrder voucherOrder = new VoucherOrder();
        voucherOrder.setId(orderId);// 订单Id
        voucherOrder.setUserId(UserHolder.getUser().getId());// 用户Id
        voucherOrder.setVoucherId(voucherId);// 代金券id
        save(voucherOrder);// 插入到数据库中
        // 7. 返回订单id
        return Result.ok(orderId);
    }

3.3 锁的粒度与事务陷阱

错误做法 :在方法上加 synchronized,锁粒度太粗。

正确做法:按用户 ID 加锁,保证同一用户串行。

java 复制代码
        //4. 判断库存是否充足
        if (seckillVoucher.getStock() < 1) {
            return Result.fail(MessageConstant.STOCK_IS_NOT_ENOUGH);// 库存不足
        }
        // 对当前用户加锁
        Long userId = UserHolder.getUser().getId();
        synchronized (userId.toString().intern()) {// intern方法获取字符串常量池中的对象,保证同一个id是一个对象
            // 获取代理对象,保证下面的事务能够正确执行
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }

两个坑:

  1. userId.toString() 每次都是新对象,必须用 intern() 从常量池取。

  2. 锁要加在事务外面 ,否则事务未提交锁就释放了;调用 createVoucherOrder 要用代理对象,否则事务失效。

AopContext的使用需要导入下面的依赖:

java 复制代码
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>

需要开启 AOP 代理暴露:

java 复制代码
@EnableAspectJAutoProxy(exposeProxy = true)

四、集群下的锁失效与分布式锁

4.1 问题

集群部署两个 Tomcat(8081、8082),每个 JVM 有自己的锁对象。用户请求落到不同 Tomcat,synchronized 锁不住。

原因:JVM 级别的锁只在单个 JVM 内有效。

测试:

通过找到下面的项目配置,复制并配置另一个端口号,这样,两个服务都可以启动。

修改nginx 请求转发,在前端conf文件夹下找到nginx.conf配置文件,将proxy_pass 改为下面那个,转发server两个都是用,形成负载均衡环境。

重启nginx服务

后端服务都启动

通过请求测试,发现两个服务都在走,一个小的集群环境搭建完成。

通过Postman测试,在debug阶段,发现两个服务对同一个userId都能够拿到锁,这给后续集群服务带来风险,因此,后续我们需要对此进行解决。

4.2 分布式锁的基本要求

  • 多进程可见:所有节点都能看到同一把锁

  • 互斥:同时只有一个线程持有

  • 高可用、高性能、安全

4.3 分布式锁的方式

分布式锁的核心是实现多进程间的互斥,常见的有三种方式:

这三种实现方式之间各有优劣,之后,我们将使用Redis实现分布式锁。

4.4 Redis分布式锁核心思路

实现分布式锁时需要实现的两个基本方法:

  • 获取锁:

    • 互斥:确保只能有一个线程获取锁

    • 非阻塞:尝试一次,成功返回true,失败返回false

  • 释放锁:

    • 手动释放

    • 超时释放:获取锁时添加一个超时时间

核心思路:

我们利用redis 的setNx 方法,当有多个线程进入时,我们就利用该方法,第一个线程进入时,redis 中就有这个key 了,返回了1,如果结果是1,则表示他抢到了锁,那么他去执行业务,然后再删除锁,退出锁逻辑,没有抢到锁的哥们,等待一定时间后重试即可

4.5 Redis实现分布式锁

ILock接口

java 复制代码
public interface ILock {
    /**
     * 尝试获取锁
     * @param timeoutSec
     * @return
     */
    boolean tryLock(long timeoutSec);
    void unLock();
}

SimpleRedisLock类来实现ILock接口,实现对应的TryLock和unLock方法

java 复制代码
public class SimpleRedisLock implements ILock{
    private String name;// 业务名称,用于拼接key
    private StringRedisTemplate stringRedisTemplate;
    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }
    private static final String KEY_PREFIX = "lock:";// key前缀
    @Override
    public boolean tryLock(long timeoutSec) {
        String key = KEY_PREFIX + name;// 拼接key
        // 获取线程标识,作为value值
        long threadId = Thread.currentThread().getId();
        // 尝试获取锁,这里使用的setIfAbsent方法,如果key不存在,则设置value,并返回true,否则返回false
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(key, threadId + "", timeoutSec, TimeUnit.SECONDS);
        // 由于自动拆箱可能存在null,所以这里采用Boolean.equals方法进行比较,防止空指针错误
        return Boolean.TRUE.equals(success);
    }
 
    @Override
    public void unLock() {
        stringRedisTemplate.delete(KEY_PREFIX + name);
    }
}

在VoucherOrderServiceImpl的seckillVoucher方法中使用该分布式锁

java 复制代码
    public Result seckillVoucher(Long voucherId) {
        // 1. 查询优惠券信息
        SeckillVoucher seckillVoucher = seckillVoucherService.getById(voucherId);
        // 2. 判断秒杀活动是否开始
        if (seckillVoucher.getBeginTime().isAfter(LocalDateTime.now())) {
            return Result.fail(MessageConstant.SECKILL_IS_NOT_START);// 活动还未开始
        }
        //3. 判断秒杀活动是否结束
        if (seckillVoucher.getEndTime().isBefore(LocalDateTime.now())) {
            return Result.fail(MessageConstant.SECKILL_IS_OVER);// 秒杀已经结束
        }
        //4. 判断库存是否充足
        if (seckillVoucher.getStock() < 1) {
            return Result.fail(MessageConstant.STOCK_IS_NOT_ENOUGH);// 库存不足
        }
        // 对当前用户加锁
        Long userId = UserHolder.getUser().getId();
        // 创建锁对象
        SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
        // 尝试获取锁
        boolean isLock = lock.tryLock(1200);
        // 判断获取锁是否成功
        if (!isLock) {
            // 获取锁失败,返回对应的错误信息
            return Result.fail(MessageConstant.REPEAT_BUY);
        }
        // 获取锁成功,进行业务操作
        try {
            // 获取代理对象,保证下面的事务能够正确执行
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        }finally {
            // 释放锁
            lock.unLock();
        }
//        synchronized (userId.toString().intern()) {// intern方法获取字符串常量池中的对象,保证同一个id是一个对象
    }

测试:通过测试,之前的一人一单功能,不再会同时有两个程序对当前用户加锁了,只会有一个加锁成功。

4.6 Redis分布式锁误删情况

存在的问题

当前分布式锁在一些极端的情况下还是会产生并发问题,如果线程1在阻塞过程中,锁因为超时过期了,此时线程2成功加锁,但在线程2执行业务的过程中,线程1完成业务并执行了释放锁操作,此时,线程1会将线程2的锁释放掉,导致线程3能在线程2业务未完成时加锁成功,从而带来并发问题。

要解决这个问题,我们需要在释放锁的时候进行一次判断,只有当前锁是自己获取的才进行释放,通过一个标识来判断锁的一致性,一旦锁不一致,则表示自己的锁是超时过期了,因此不需要释放锁的操作。

整体业务流程更改如下:(用UUID+当前线程ID作为标识)

修改之前的分布式锁实现,满足:

  1. 在获取锁时存入线程标识(这里用UUID+线程ID作为标识)
  2. 在释放锁时先获取锁中的线程标识,然后与当前线程标识进行判断
    1. 如果一致,则释放该锁
    2. 如果不一致,则不进行任何操作

修改加锁操作,增加标识

java 复制代码
    private static final String KEY_PREFIX = "lock:";// key前缀
    private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";// 标识前缀
    @Override
    public boolean tryLock(long timeoutSec) {
        String key = KEY_PREFIX + name;// 拼接key
        // 获取线程标识,作为value值
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        // 尝试获取锁,这里使用的setIfAbsent方法,如果key不存在,则设置value,并返回true,否则返回false
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(key, threadId, timeoutSec, TimeUnit.SECONDS);
        // 由于自动拆箱可能存在null,所以这里采用Boolean.equals方法进行比较,防止空指针错误

修改释放锁操作,增加标识判断功能

java 复制代码
    @Override
    public void unLock() {
        // 线程标识
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        // 获取锁标识
        String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
        // 判断是否为当前线程的锁,如果是则删除锁,不是则不进行任何操作
        if (threadId.equals(id)) {
            // 释放锁
            stringRedisTemplate.delete(KEY_PREFIX + name);
        }
    }

测试,成功实现只释放自己的锁的功能。

4.7 原子性问题与 Lua 脚本

问题:判断锁归属和删除锁之间如果阻塞,锁过期后可能误删别人的锁。

释放锁的业务流程:

1、获取锁中的线程标示

2、判断是否与指定的标示(当前线程标示)一致

3、如果一致则释放锁(删除)

4、如果不一致则什么都不做

解决:用 Lua 脚本保证判断和删除的原子性。

Lua 复制代码
-- 这里的 KEYS[1] 就是锁的key,这里的ARGV[1] 就是当前线程标示
-- 获取锁中的标示,判断是否与当前线程标示一致
if (redis.call('GET', KEYS[1]) == ARGV[1]) then
  -- 一致,则删除锁
  return redis.call('DEL', KEYS[1])
end
-- 不一致,则直接返回
return 0

Java 调用:

java 复制代码
    // 提前加载脚本
    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;
    static {
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));// 加载脚本
        UNLOCK_SCRIPT.setResultType(Long.class);// 设置脚本返回值类型
    }
    // 脚本修改释放锁代码
    @Override
    public void unLock() {
        // 获取锁标识,封装到keys集合中
        List<String> keys = Collections.singletonList(KEY_PREFIX + name);
        // 线程标识
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        // 调用lua脚本
        stringRedisTemplate.execute(UNLOCK_SCRIPT, keys, threadId);
    }

五、Redisson:生产级分布式锁

5.1 自己实现的锁还有什么问题?

5.2 Redisson 快速入门

引入依赖:

java 复制代码
<dependency>
	<groupId>org.redisson</groupId>
	<artifactId>redisson</artifactId>
	<version>3.13.6</version>
</dependency>

配置客户端:

java 复制代码
@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient(){
        // 配置
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.150.101:6379")
            .setPassword("123321");
        // 创建RedissonClient对象
        return Redisson.create(config);
    }
}

使用锁:

java 复制代码
@Resource
private RedissionClient redissonClient;

@Test
void testRedisson() throws Exception{
    //获取锁(可重入),指定锁的名称
    RLock lock = redissonClient.getLock("anyLock");
    //尝试获取锁,参数分别是:获取锁的最大等待时间(期间会重试),锁自动释放时间,时间单位
    boolean isLock = lock.tryLock(1,10,TimeUnit.SECONDS);
    //判断获取锁成功
    if(isLock){
        try{
            System.out.println("执行业务");          
        }finally{
            //释放锁
            lock.unlock();
        }
    }
}

在 VoucherOrderServiceImpl

注入RedissonClient

java 复制代码
@Resource
private RedissonClient redissonClient;

@Override
public Result seckillVoucher(Long voucherId) {
        // 1.查询优惠券
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        // 2.判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
            // 尚未开始
            return Result.fail("秒杀尚未开始!");
        }
        // 3.判断秒杀是否已经结束
        if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
            // 尚未开始
            return Result.fail("秒杀已经结束!");
        }
        // 4.判断库存是否充足
        if (voucher.getStock() < 1) {
            // 库存不足
            return Result.fail("库存不足!");
        }
        Long userId = UserHolder.getUser().getId();
        //创建锁对象 这个代码不用了,因为我们现在要使用分布式锁
        //SimpleRedisLock lock = new SimpleRedisLock("order:" + userId, stringRedisTemplate);
        RLock lock = redissonClient.getLock("lock:order:" + userId);
        //获取锁对象
        boolean isLock = lock.tryLock();
       
		//加锁失败
        if (!isLock) {
            return Result.fail("不允许重复下单");
        }
        try {
            //获取代理对象(事务)
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);
        } finally {
            //释放锁
            lock.unlock();
        }
 }

5.3 Redisson 核心机制

机制 原理
可重入 Hash 结构存储 线程标识 -> 重入次数,加锁 +1,释放 -1,为 0 才删除
可重试 基于 PubSub 订阅锁释放消息,等待唤醒后重试
看门狗 不指定过期时间时,默认 30s,每 10s 续期一次,直到锁释放
MultiLock 向所有主节点加锁,全部成功才算加锁成功,解决主从一致性问题

六、秒杀异步优化

6.1 为什么要异步?

原始流程: 查优惠券 → 判断时间 → 判断库存 → 查订单(一人一单)→ 扣库存 → 创建订单。

全部串行,且多次访问数据库,并发能力差。

优化思路 :把库存判断、一人一单判断 放到 Redis 中快速完成,订单创建交给异步线程慢慢做。

6.2 用 Lua 脚本完成资格判断

需求:

  • 新增秒杀优惠券的同时,将优惠券信息保存到Redis中

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

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

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

需求1:创建秒杀订单时将库存存入Redis中

只需要在创建秒杀订单的方法中addSeckillVoucher,增加一个对Redis的操作即可,这里我们用String类型来存储库存。

java 复制代码
    @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中
        stringRedisTemplate.opsForValue().set(RedisConstants.SECKILL_STOCK_KEY+voucher.getId(), voucher.getStock().toString());
    }

测试:

在redis中存在库存的缓存

需求2:基于Lua脚本,实现判断秒杀库存、一人一单功能

库存不足返回1,重复下单返回2,抢购成功返回0

Lua 复制代码
-- 1. 传入的参数列表
-- 1.1 优惠券id
local voucherId =  ARGV[1];
-- 1.2 用户id
local userId = ARGV[2];
-- 2. 数据key
-- 2.1 库存key Lua脚本中使用..来拼接字符串
local stockKey = 'seckill:stock:' .. voucherId;
-- 2.2 订单key
local orderKey = 'seckill:order:' .. voucherId;
-- 3. 脚本业务
-- 3.1 判断库存是否充足,tonumber用于将字符串转变成数组进行比较
if (tonumber(redis.call('get', stockKey)) <= 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);
-- 返回抢购成功
return 0;

在秒杀订单功能中使用:

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);
    }
    /**
     * 优惠券秒杀订单优化
     * @param voucherId
     * @return
     */
    @Override
    public Result seckillVoucher(Long voucherId) {
        // 获取当前用户ID
        Long userId = UserHolder.getUser().getId();
        // 1.执行Lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(),
                userId.toString());
        // 2.判断执行的结果
        int r = result.intValue();
        if (r != 0) {
            // 2.0 执行结果不为0,返回对应的错误信息,1为库存不足,2为重复下单
            return Result.fail(r == 1? MessageConstant.STOCK_IS_NOT_ENOUGH: MessageConstant.REPEAT_BUY);
        }
        // 2.2 执行结果为0,把下单信息保存到阻塞队列中
        // TODO 保存阻塞队列
 
        // 3. 返回订单id
        Long orderId = redisIdWorker.nextId("order");
        return Result.ok(orderId);
    }

测试:在redis中成功实现减库存和一人一单功能,此时,因为还未编写阻塞队列代码,所以数据库中不变。

需求3:抢购成功后,将优惠券id和用户id封装后存入阻塞队列

创建一个阻塞队列,后续开启异步下单后,不存在数据时会阻塞

java 复制代码
    // 阻塞队列,用于保存订单信息,以便于异步创建订单
    private BlockingQueue<VoucherOrder> orderTasks = new ArrayBlockingQueue<>(1024*1024);

在seckillVoucher方法中,将用户id、订单id、秒杀券id封装为订单,加入到阻塞队列中,在这里获取当前代理对象用于后续保证创建订单的业务能够正确执行。

java 复制代码
    @Override
    public Result seckillVoucher(Long voucherId) {
        // 获取当前用户ID
        Long userId = UserHolder.getUser().getId();
        // 1.执行Lua脚本
        Long result = stringRedisTemplate.execute(
                SECKILL_SCRIPT,
                Collections.emptyList(),
                voucherId.toString(),
                userId.toString());
        // 2.判断执行的结果
        int r = result.intValue();
        if (r != 0) {
            // 2.0 执行结果不为0,返回对应的错误信息,1为库存不足,2为重复下单
            return Result.fail(r == 1? MessageConstant.STOCK_IS_NOT_ENOUGH: MessageConstant.REPEAT_BUY);
        }
        // 2.2 执行结果为0,把下单信息保存到阻塞队列中
        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);
        // 2.6 放入到阻塞队列中
        orderTasks.add(voucherOrder);
        // 3. 获取代理对象
        proxy = (IVoucherOrderService) AopContext.currentProxy();
        // 4. 返回订单id
        return Result.ok(orderId);
    }
需求4:开启线程任务,不断从阻塞队列中获取订单信息,实现异步下单的功能

创建一个内部类,用于获取阻塞队列中的信息并创建订单

java 复制代码
    /**
     * 内部类,用于处理阻塞队列中的订单,进行订单创建
     */
    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);
                }
            }
        }
    }

一个新的创建订单方法,用户ID和秒杀券id信息通过传入的订单信息获取,因为后续执行的是异步操作,无法通过ThreadLocal获取这些信息,这里查询用户和秒杀券的操作其实可以不做,因为在之前的redis中已经做了一人一单操作,这里为了防止redis出错,进行兜底。

java 复制代码
    /**
     * 新的订单创建方式,传入的是封装好的订单信息,包括用户id,订单id和秒杀券id
     * @param voucherOrder
     */
    @Override
    public void createVoucherOrder(VoucherOrder voucherOrder) {
        // 1.获取当前用户Id
        Long userId = voucherOrder.getUserId();
        Long voucherId = voucherOrder.getVoucherId();
        // 2.查询订单中是否存在当前用户和秒杀券信息
        Integer count = query().eq("user_id", userId)
                .eq("voucher_id", voucherId)
                .count();
        // 3.判断订单是否存在
        if (count > 0) {
            log.error(MessageConstant.REPEAT_BUY);
            return;// 禁止重复购买
        }
        // 4. 扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock = stock - 1")
                .eq("voucher_id", voucherId)
//                .eq("stock", seckillVoucher.getStock()) // 乐观锁,判断库存是否被修改
                .gt("stock", 0)// 剩余库存大于0才扣减库存
                .update();
        if (!success) {
            // 5扣减库存失败,返回错误信息
            log.error(MessageConstant.STOCK_IS_NOT_ENOUGH);
            return;
        }
        // 6. 不用创建订单了,直接插入传入的订单
        save(voucherOrder);// 插入到数据库中
    }

内部类调用的创建订单的方法,这里其实也可以不加锁,加锁同样是为了兜底,其实前面redis只要不出错,这里每个到达的订单信息都是不同用户,且不超过库存的。

java 复制代码
    /**
     * 新建订单的方法,增加一道分布式锁的机制,来防止redis删减库存等步骤出问题,进一步保证一人一单功能
     * @param voucherOrder
     */
    private void handleVoucherOrder(VoucherOrder voucherOrder) {
        // 对当前用户加锁,注意这里需要从voucherOrder中获取用户(因为是异步执行的)
        Long userId = voucherOrder.getUserId();
        // 创建锁对象
        RLock lock = redissonClient.getLock("lock:order" + userId);
        // 尝试获取锁,使用无参构造,默认不等待,超时时间为30s
        boolean isLock = lock.tryLock();
        // 判断获取锁是否成功
        if (!isLock) {
            // 获取锁失败,返回对应的错误信息
            log.error(MessageConstant.REPEAT_BUY);
            return;
        }
        // 获取锁成功,进行业务操作
        try {
            // 代理对象保证下面的事务能够正确执行
            proxy.createVoucherOrder(voucherOrder);
        }finally {
            // 释放锁
            lock.unlock();
        }
    }

创建线程池并使用Spring的@PostConstruct注解将异步执行方法用新线程执行,即确保init方法提交一个 VoucherOrderHandler 实例到 SECKILL_ORDER_EXECUTOR 线程池中执行,用于异步处理订单创建任务。

java 复制代码
    // 线程池,用于异步执行创建订单的业务
    private static final ExecutorService SECKILL_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();
 
    @PostConstruct
    private void init(){
        SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
    }

测试:成功实现异步创建订单功能,每次请求的线程只对redis中的库存和订单进行处理,将订单信息加入阻塞队列中,使用异步线程实现对数据库的写入操作。

总结一些这里的秒杀订单优化思路:

利用Redis完成库存判断、一人一单判断,实现抢单业务,业务执行速度更快

将订单放入阻塞队列中,利用独立的线程进行异步下单操作,进行实际的数据库插入操作

基于阻塞队列的异步秒杀存在的问题:

内存限制问题: 阻塞队列是在jvm中存在的,在高并发情况下会创建多个阻塞队列,且目前限制了阻塞队列的大小,导致部分数据由于内存不足无法存储。

**数据安全问题:**阻塞队列不具有持久性,异步线程创建订单具有延时性,当redis完成抢单业务,但异步线程还未执行完时发生故障或服务重启时,阻塞队列中的数据会丢失,导致实际的抢单业务未完成,造成数据库和redis中数据不一致,导致后续带来安全问题。

七、认识消息队列

7.1 什么是消息队列?

消息队列(Message Queue,简称 MQ)就是存放消息的队列。最简单的模型包含三个角色:

角色 说明
消息队列(Broker) 存储和管理消息
生产者(Producer) 发送消息到队列
消费者(Consumer) 从队列获取消息并处理
java 复制代码
生产者 ──发送消息──> 消息队列 ──获取消息──> 消费者

7.2 为什么需要消息队列?

核心价值:解耦 + 异步。

生活中的例子:快递员(生产者)把快递放进快递柜(消息队列),你(消费者)有空再去取。如果快递员必须当面交给你,你不在家他就得一直等------这就是耦合的代价。

秒杀场景中:

  • 没有消息队列:用户请求 → 判断库存 → 扣库存 → 创建订单 → 返回,全部串行,响应慢

  • 有消息队列:用户请求 → Redis 快速判断资格 → 发消息到队列 → 立即返回;后台线程慢慢消费消息创建订单

消息队列把"快速判断"和"耗时落库"分开,用户只等前者,体验大幅提升。

7.3 Redis 的三种消息队列方案

方案 数据结构 特点
List 双向链表 简单,但只支持单消费者,可能丢消息
PubSub 发布订阅 支持多消费者,但不持久化,可能丢消息
Stream 5.0 新类型 功能完善,支持消费者组、ACK 确认,可靠性最高
7.3.1基于 List 实现消息队列
1. 基本思路

Redis 的 List 是双向链表,天然适合模拟队列:

  • 左进右出 :LPUSH + RPOP

  • 右进左出 :RPUSH + LPOP

但 RPOP/LPOP 在队列为空时返回 null,不会阻塞等待。要实现阻塞效果,需要用 BRPOP/BLPOP(B = Blocking)。

java 复制代码
# 生产者:从左边放入消息
LPUSH queue msg1 msg2 msg3

# 消费者:从右边阻塞弹出,最多等 5 秒
BRPOP queue 5
2. 优缺点

优点:

  • 基于 Redis 存储,不受 JVM 内存上限限制

  • 基于 Redis 持久化机制,数据相对安全

  • 消息有序

缺点:

  • 无法避免消息丢失:消息被取出但还没处理完时服务宕机,消息就丢了

  • 只支持单消费者:一条消息只能被一个消费者取走

List 适合简单的、对可靠性要求不高的场景。


7.3.2 基于 PubSub 实现消息队列
1. 基本思路

PubSub(Publish/Subscribe,发布订阅)是 Redis 2.0 引入的消息模型:

  • 消费者订阅一个或多个频道(channel)

  • 生产者向频道发布消息

  • 所有订阅了该频道的消费者都能收到消息

java 复制代码
# 消费者订阅频道
SUBSCRIBE order.channel

# 生产者发布消息
PUBLISH order.channel "new order"

# 按模式订阅(支持通配符 ? * [ae])
PSUBSCRIBE order.*
2. 优缺点

优点:

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

缺点:

  • 不支持数据持久化:消息不存储,服务宕机即丢失

  • 无法避免消息丢失

  • 消息堆积有上限:消费者缓冲区满了,新消息直接丢失

PubSub 适合实时广播场景(如聊天室、实时通知),不适合要求可靠性的业务。


7.3.3 基于 Stream 实现消息队列
1. Stream 是什么?

Stream 是 Redis 5.0 引入的新数据类型,专门为消息队列设计。它持久化存储 ,支持消费者组 、消息确认,是目前 Redis 最完善的消息队列方案。

2. 基本命令

发送消息:XADD

java 复制代码
XADD stream.orders * userId 101 voucherId 5 id 1001
  • *:让 Redis 自动生成消息 ID(格式:时间戳-递增序号,如 1644804662707-0)

  • 后面是键值对形式的消息内容(一个 Entry 可以包含多个字段)

读取消息:XREAD

java 复制代码
# 从第一条消息开始读
XREAD COUNT 1 STREAMS stream.orders 0

# 阻塞读取最新消息,最多等 2 秒
XREAD COUNT 1 BLOCK 2000 STREAMS stream.orders $
参数 说明
COUNT n 每次最多读 n 条
BLOCK ms 没有消息时阻塞等待毫秒数,0 表示不阻塞
STREAMS key 指定队列名
ID 起始 ID:0 从第一条开始,$ 从最新一条开始
3. XREAD 的漏读问题

用 $ 作为起始 ID 时,如果处理一条消息期间又来了多条消息,下次读取只能拿到最新的一条,中间的消息被漏掉。

这就是为什么需要消费者组。

4. 消费者组(Consumer Group)

消费者组把多个消费者划分到一组,共同监听同一个队列,具备三大特性:

特性 说明
消息分流 一条消息只会分给组内一个消费者,加快处理速度
消息标识 组内维护一个"最后处理位置",消费者宕机重启后从该位置继续,降低漏读
消息确认(ACK) 消息被读取后进入 pending-list,处理完需 XACK 确认,未确认的可重新处理

创建消费者组

java 复制代码
XGROUP CREATE stream.orders g1 0 MKSTREAM
  • g1:组名

  • 0:从第一条消息开始;$ 表示从最新消息开始

  • MKSTREAM:队列不存在时自动创建

从消费者组读取消息

java 复制代码
XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS stream.orders >
  • g1:组名

  • c1:消费者名(不存在会自动创建)

  • >:从下一个未消费的消息开始读

  • 其他 ID(如 0):从 pending-list 中读取已消费但未确认的消息

确认消息

java 复制代码
XACK stream.orders g1 1644804662707-0

其他常用命令

java 复制代码
XGROUP DESTROY stream.orders g1              # 删除消费者组
XGROUP CREATECONSUMER stream.orders g1 c2    # 添加消费者
XGROUP DELCONSUMER stream.orders g1 c2       # 删除消费者
5. 消费者组的工作流程
java 复制代码
1. 消费者组 g1 监听 stream.orders
2. 多个消费者 c1、c2 竞争读取消息(> 表示读新消息)
3. 读到的消息进入 pending-list,状态为"已投递未确认"
4. 消费者处理完,调用 XACK 确认,消息从 pending-list 移除
5. 若消费者处理中宕机,消息留在 pending-list
6. 重启后用 ID=0 从 pending-list 重新读取,保证至少消费一次
6. Stream 消费者组的优势
特点 说明
消息可回溯 消息持久化,可多次读取
多消费者争抢 加快消费速度
可阻塞读取 BLOCK 参数
无漏读风险 消费者组记录位置 + pending-list
消息确认机制 保证消息至少被消费一次

7.4 三种方案对比

结论 :秒杀这类要求"消息不丢、至少消费一次"的场景,首选 Stream。


7.5 实战:用 Stream 改造异步秒杀

整体思路
java 复制代码
用户请求
   ↓
Lua 脚本(原子操作):
  1. 判断库存
  2. 判断一人一单
  3. 扣库存
  4. 记录用户到 Set
  5. XADD 发送消息到 stream.orders
   ↓
立即返回订单 ID
   ↓
后台线程(消费者组 g1 的 c1):
  1. XREADGROUP 读取消息
  2. 创建订单(写数据库)
  3. XACK 确认
  异常时 → 处理 pending-list
第一步:创建 Stream 和消费者组

项目启动时确保队列和消费者组存在(可用命令或代码初始化):

java 复制代码
XGROUP CREATE stream.orders g1 0 MKSTREAM
第二步:修改 Lua 脚本

在原有秒杀脚本末尾,抢购成功后直接发送消息到 Stream:

Lua 复制代码
-- 1. 参数
local voucherId = ARGV[1]
local userId = ARGV[2]
local orderId = ARGV[3]

-- 2. Key
local stockKey = 'seckill:stock:' .. voucherId
local orderKey = 'seckill:order:' .. voucherId

-- 3. 判断库存
if (tonumber(redis.call('get', stockKey)) <= 0) then
    return 1
end

-- 4. 判断一人一单
if (redis.call('sismember', orderKey, userId) == 1) then
    return 2
end

-- 5. 扣库存、记录用户
redis.call('incrby', stockKey, -1)
redis.call('sadd', orderKey, userId)

-- 6. 发送消息到 Stream(字段名与 VoucherOrder 属性对应)
redis.call('xadd', 'stream.orders', '*',
    'userId', userId,
    'voucherId', voucherId,
    'id', orderId)

return 0

消息字段名 userId、voucherId、id 要和 VoucherOrder 实体类属性一致,方便后续 BeanUtil.fillBeanWithMap 自动填充。

第三步:Java 调用 Lua 脚本
java 复制代码
@Override
public Result seckillVoucher(Long voucherId) {
    Long userId = UserHolder.getUser().getId();
    long orderId = redisIdWorker.nextId("order");

    // 执行 Lua 脚本
    Long result = stringRedisTemplate.execute(
            SECKILL_SCRIPT,
            Collections.emptyList(),
            voucherId.toString(),
            userId.toString(),
            String.valueOf(orderId)
    );

    int r = result.intValue();
    if (r != 0) {
        return Result.fail(r == 1 ? "库存不足" : "不能重复下单");
    }

    // 消息已在 Lua 中发送,直接返回订单 ID
    return Result.ok(orderId);
}

注意:相比阻塞队列版本,这里不需要手动封装 VoucherOrder 再放入队列,Lua 脚本已经完成消息发送。

第四步:后台线程消费消息
java 复制代码
private static final ExecutorService SECKILL_ORDER_EXECUTOR =
        Executors.newSingleThreadExecutor();

private static final String QUEUE_NAME = "stream.orders";

@PostConstruct
private void init() {
    SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
}

private class VoucherOrderHandler implements Runnable {
    @Override
    public void run() {
        while (true) {
            try {
                // 1. 从消费者组读取新消息(> 表示下一个未消费)
                List<MapRecord<String, Object, Object>> list =
                        stringRedisTemplate.opsForStream().read(
                                Consumer.from("g1", "c1"),
                                StreamReadOptions.empty().count(1)
                                        .block(Duration.ofSeconds(2)),
                                StreamOffset.create(QUEUE_NAME,
                                        ReadOffset.lastConsumed())
                        );

                // 2. 没有消息,继续循环
                if (list == null || list.isEmpty()) {
                    continue;
                }

                // 3. 解析消息
                MapRecord<String, Object, Object> record = list.get(0);
                VoucherOrder order = BeanUtil.fillBeanWithMap(
                        record.getValue(), new VoucherOrder(), true);

                // 4. 创建订单
                handleVoucherOrder(order);

                // 5. ACK 确认
                stringRedisTemplate.opsForStream()
                        .acknowledge(QUEUE_NAME, "g1", record.getId());

            } catch (Exception e) {
                log.error("处理订单异常", e);
                // 出现异常,处理 pending-list
                handlePendingList();
            }
        }
    }
}
第五步:处理 pending-list

当消费者处理消息时抛出异常,消息会留在 pending-list 中。需要单独处理,保证"至少消费一次":

java 复制代码
private void handlePendingList() {
    while (true) {
        try {
            // 1. 从 pending-list 读取(ID=0 表示第一个未确认消息)
            List<MapRecord<String, Object, Object>> list =
                    stringRedisTemplate.opsForStream().read(
                            Consumer.from("g1", "c1"),
                            StreamReadOptions.empty().count(1),
                            StreamOffset.create(QUEUE_NAME,
                                    ReadOffset.from("0"))
                    );

            // 2. pending-list 为空,结束
            if (list == null || list.isEmpty()) {
                break;
            }

            // 3. 解析并重试
            MapRecord<String, Object, Object> record = list.get(0);
            VoucherOrder order = BeanUtil.fillBeanWithMap(
                    record.getValue(), new VoucherOrder(), true);
            handleVoucherOrder(order);

            // 4. ACK
            stringRedisTemplate.opsForStream()
                    .acknowledge(QUEUE_NAME, "g1", record.getId());

        } catch (Exception e) {
            log.error("处理 pending-list 异常", e);
            try {
                Thread.sleep(20);  // 避免空转
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            }
        }
    }
}
订单落库(带兜底)
java 复制代码
private void handleVoucherOrder(VoucherOrder order) {
    Long userId = order.getUserId();

    // 分布式锁兜底,防止极端情况下重复
    RLock lock = redissonClient.getLock("lock:order:" + userId);
    boolean isLock = lock.tryLock();
    if (!isLock) {
        log.error("不允许重复下单");
        return;
    }

    try {
        proxy.createVoucherOrder(order);
    } finally {
        lock.unlock();
    }
}
java 复制代码
@Transactional
public void createVoucherOrder(VoucherOrder order) {
    Long userId = order.getUserId();
    Long voucherId = order.getVoucherId();

    // 兜底:查数据库确认未重复下单
    int count = query().eq("user_id", userId)
            .eq("voucher_id", voucherId).count();
    if (count > 0) {
        log.error("用户已购买过");
        return;
    }

    // 扣库存
    boolean success = seckillVoucherService.update()
            .setSql("stock = stock - 1")
            .eq("voucher_id", voucherId)
            .gt("stock", 0)
            .update();
    if (!success) {
        log.error("库存不足");
        return;
    }

    // 创建订单
    save(order);
}

八、总结

问题 解决方案
订单 ID 规律暴露 Redis 拼接时间戳 + 序列号生成全局唯一 ID
超卖 乐观锁 stock > 0 条件更新
一人一单 按用户 ID 加锁 + 事务 + 代理对象
集群锁失效 Redis 分布式锁 SET NX EX
锁误删 线程标识 + Lua 脚本原子释放
锁的续期/重试/可重入 Redisson
秒杀性能 Lua 脚本 Redis 预判 + Stream 异步下单
相关推荐
秋天的怀念_David1 小时前
算法一千零一夜 · 第三十五夜 · 恢复风暴
java·程序人生·算法
考虑考虑1 小时前
JDK27中的加密对象的 PEM 编码
java·后端·java ee
行者-全栈开发1 小时前
SpringBoot + GraalVM 原生编译实战:启动时间从8秒到0.5秒的极致优化
java·spring boot·后端
CoderYanger2 小时前
Java EE 进阶:10. MyBatis-Plus使用(第一弹)
java·spring boot·后端·sql·spring·java-ee·mybatis
大胖爱学习_MJ4 小时前
超越向量检索:用 Spring Boot + Neo4j 手搓 GraphRAG 知识图谱记忆
java·后端·python
吃我一窝jio4 小时前
Java博客极简写作三支柱
java
知识搬运临时工4 小时前
双路服务器跑得比单路慢:JVM 没看见内存的距离
java·后端
吃我一窝jio5 小时前
Java Bug复盘与性能优化实战
java·开发语言·笔记
Flynn Liang5 小时前
Java 序列化也能成为瓶颈:Jackson、Protobuf 与 Redis 序列化的生产实践
java·redis·性能优化·jackson·序列化·protobuf