@Component
public class RedisIdWorker {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    // 基准时间：2022-01-01 00:00:00 UTC
    private static final long BEGIN_TIMESTAMP = 1640995200L;

    // 序列号位数
    private static final int COUNT_BITS = 32;

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

        // 2. 生成序列号（精确到天，每天一个 key）
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        long count = stringRedisTemplate.opsForValue()
                .increment("icr:" + keyPrefix + ":" + date);

        // 3. 位运算拼接：时间戳左移 32 位，再与序列号做或运算
        return timestamp << COUNT_BITS | count;
    }
}

@Transactional
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("库存不足");
    }

    // 5. 扣减库存
    boolean success = seckillVoucherService.update()
            .setSql("stock = stock - 1")
            .eq("voucher_id", voucherId)
            .update();
    if (!success) {
        return Result.fail("库存不足");
    }

    // 6. 创建订单
    VoucherOrder order = new VoucherOrder();
    order.setId(redisIdWorker.nextId("order"));
    order.setUserId(UserHolder.getUser().getId());
    order.setVoucherId(voucherId);
    voucherOrderService.save(order);

    return Result.ok(order.getId());
}

-- 查询时获取版本号
SELECT stock, version FROM seckill_voucher WHERE voucher_id = 10;

-- 更新时带上版本号判断
UPDATE seckill_voucher
SET stock = stock - 1, version = version + 1
WHERE voucher_id = 10 AND version = 1;

UPDATE seckill_voucher
SET stock = stock - 1
WHERE voucher_id = 10 AND stock = 1;  -- stock 等于查询时的值

-- 不再判断 stock 是否等于查询值，而是判断 stock > 0
UPDATE seckill_voucher
SET stock = stock - 1
WHERE voucher_id = 10 AND stock > 0;

// 外层获取锁，确保事务提交后才释放
Long userId = UserHolder.getUser().getId();
synchronized (userId.toString().intern()) {
    // intern() 确保相同值的字符串指向同一对象（锁对象一致）
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
    return proxy.createVoucherOrder(voucherId);
}

@Transactional
public Result createVoucherOrder(Long voucherId) {
    // 一人一单判断
    Long userId = UserHolder.getUser().getId();
    int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
    if (count > 0) {
        return Result.fail("该用户已经购买过");
    }

    // 扣减库存
    boolean success = seckillVoucherService.update()
            .setSql("stock = stock - 1")
            .eq("voucher_id", voucherId).gt("stock", 0)
            .update();

    // 创建订单
    VoucherOrder order = new VoucherOrder();
    order.setId(redisIdWorker.nextId("order"));
    order.setUserId(userId);
    order.setVoucherId(voucherId);
    save(order);

    return Result.ok(order.getId());
}

-- 参数: 1-优惠券ID, 2-用户ID, 3-订单ID
local voucherId = ARGV[1]
local userId = ARGV[2]
local orderId = ARGV[3]

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

-- 1. 判断库存是否充足
if (tonumber(redis.call('get', stockKey)) <= 0) then
    return 1  -- 库存不足
end

-- 2. 判断用户是否已下单
if (redis.call('sismember', orderKey, userId) == 1) then
    return 2  -- 重复下单
end

-- 3. 扣减库存
redis.call('incrby', stockKey, -1)

-- 4. 保存用户到已购集合
redis.call('sadd', orderKey, userId)

-- 5. 发送消息到 Stream 消息队列
redis.call('xadd', 'stream.orders', '*', 'userId', userId, 'voucherId', voucherId, 'id', orderId)

return 0  -- 有购买资格

public Result seckillVoucher(Long voucherId) {
    Long userId = UserHolder.getUser().getId();
    Long orderId = redisIdWorker.nextId("order");

    // 1. 执行 Lua 脚本判断秒杀资格
    Long result = stringRedisTemplate.execute(
            seckillScript,
            Collections.emptyList(),
            voucherId.toString(), userId.toString(), orderId.toString()
    );

    // 2. 判断结果
    if (result != 0) {
        return Result.fail(result == 1 ? "库存不足" : "不能重复下单");
    }

    // 3. 有资格，返回订单 ID（实际下单由异步线程处理）
    return Result.ok(orderId);
}

# 创建队列和消费者组（mkstream 参数自动创建不存在的队列）
XGROUP CREATE stream.orders g1 0 MKSTREAM

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

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);
                Map<Object, Object> value = record.getValue();
                VoucherOrder order = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);

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

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

            } catch (Exception e) {
                log.error("处理订单异常", e);
                handlePendingList();
            }
        }
    }

    private void handlePendingList() {
        while (true) {
            try {
                // 从 pending list 读取未确认消息
                List<MapRecord<String, Object, Object>> list = stringRedisTemplate.opsForStream().read(
                    Consumer.from("g1", "c1"),
                    StreamReadOptions.empty().count(1),
                    StreamOffset.create(QUEUE_NAME, ReadOffset.from("0"))
                );

                if (list == null || list.isEmpty()) {
                    break;  // 没有异常消息，结束
                }

                MapRecord<String, Object, Object> record = list.get(0);
                Map<Object, Object> value = record.getValue();
                VoucherOrder order = BeanUtil.fillBeanWithMap(value, new VoucherOrder(), true);
                handleVoucherOrder(order);
                stringRedisTemplate.opsForStream().acknowledge(QUEUE_NAME, "g1", record.getId());

            } catch (Exception e) {
                log.error("处理 pending list 异常", e);
                try { Thread.sleep(20); } catch (InterruptedException ex) {}
            }
        }
    }
}

private void handleVoucherOrder(VoucherOrder order) {
    Long userId = order.getUserId();

    // 获取锁（兜底，Redis 已做过判断）
    RLock lock = redissonClient.getLock("lock:order:" + userId);
    boolean isLock = lock.tryLock(1, 10, TimeUnit.SECONDS);
    if (!isLock) {
        log.error("不允许重复下单");
        return;
    }

    try {
        // 获取代理对象创建订单
        proxy.createVoucherOrder(order);
    } finally {
        lock.unlock();
    }
}