高并发下的抢优惠券如何设计

-- 原子性库存扣减脚本
local key = KEYS[1]
local field = ARGV[1]
local num = tonumber(ARGV[2])

local stock = tonumber(redis.call('HGET', key, field))
if not stock or stock < num then
    return 0  -- 库存不足
end
redis.call('HINCRBY', key, field, -num)
return 1  -- 扣减成功

令牌桶像一个水库，每秒放入固定令牌，请求取不到令牌就直接拒绝，
保证下游压力恒定。

SET coupon:stock:12345 100000

-- 原子扣减库存的 Lua 脚本
local key = KEYS[1]
local stock = tonumber(redis.call('get', key))
if stock and stock > 0 then
    redis.call('decr', key)
    return 1  -- 抢券成功
else
    return 0  -- 库存不足
end

Long result = redisTemplate.execute(
    luaScript, 
    Collections.singletonList("coupon:stock:12345"));
if (result == 1) {
    // 扣减成功，发消息异步发券
}

-- 文件名：coupon_stock_deduct.lua
-- KEYS[1]: 优惠券库存HashKey coupon:{activityId}
-- ARGV[1]: 批次ID batchId
-- ARGV[2]: 扣减数量（通常为1）
-- ARGV[3]: 用户ID（用于日志追踪）
-- 返回值：1=扣减成功 0=库存不足 -1=参数错误

-- 1. 参数校验
if #KEYS ~= 1 or #ARGV ~= 3 then
    return -1
end

local key = KEYS[1]
local batchId = ARGV[1]
local deductNum = tonumber(ARGV[2])
local userId = ARGV[3]

if deductNum <= 0 then
    return -1
end

-- 2. 原子性库存校验与扣减
local currentStock = tonumber(redis.call('HGET', key, batchId))
if not currentStock or currentStock < deductNum then
    return 0
end

redis.call('HINCRBY', key, batchId, -deductNum)
-- 可选：记录扣减日志，用于事后对账
redis.call('LPUSH', 'coupon:deduct:log:'..key, userId..':'..batchId..':'..deductNum..':'..redis.call('TIME')[1])
return 1

@RestController
@RequestMapping("/coupon")
public class CouponController {

    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    // 预加载Lua脚本，避免每次编译
    private final DefaultRedisScript<Long> deductScript;

    // 构造器初始化Lua脚本（启动时只编译一次）
    public CouponController() {
        deductScript = new DefaultRedisScript<>();
        deductScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/coupon_stock_deduct.lua")));
        deductScript.setResultType(Long.class);
    }

    @SentinelResource(value = "grabCoupon", blockHandler = "grabCouponBlockHandler")
    @PostMapping("/grab/{activityId}")
    public ResponseEntity<String> grabCoupon(@PathVariable Long activityId, @RequestParam Long userId) {
        // 1. 快速失败：活动状态校验（本地缓存，避免查DB）
        if (!ActivityCache.isActivityActive(activityId)) {
            return ResponseEntity.ok("活动已结束");
        }

        // 2. 防重领取：SETNX原子锁，过期时间=活动时长
        String userLockKey = "user:" + userId + ":coupon:" + activityId;
        Boolean isFirstGrab = redisTemplate.opsForValue().setIfAbsent(userLockKey, "1", Duration.ofHours(2));
        if (Boolean.FALSE.equals(isFirstGrab)) {
            return ResponseEntity.ok("您已参与过本次活动");
        }

        try {
            // 3. 执行Lua脚本原子扣减库存
            String stockKey = "coupon:" + activityId;
            Long result = redisTemplate.execute(
                deductScript,
                Collections.singletonList(stockKey),
                "batch_001", // 这里简化为单批次，实际可做负载均衡选择批次
                "1",
                userId.toString()
            );

            if (result == null || result == 0) {
                // 库存不足，删除防重锁，允许用户重试
                redisTemplate.delete(userLockKey);
                return ResponseEntity.ok("优惠券已抢完");
            } else if (result == -1) {
                return ResponseEntity.badRequest().body("参数错误");
            }

            // 4. 扣减成功，发送MQ异步生成用户券
            CouponMessage message = new CouponMessage(activityId, userId, "batch_001");
            rocketMQTemplate.convertAndSend("coupon-create-topic", message);

            return ResponseEntity.ok("抢券成功，优惠券将在1-2分钟内到账");
        } catch (Exception e) {
            // 异常回滚：删除防重锁，允许用户重试
            redisTemplate.delete(userLockKey);
            log.error("抢券异常，userId:{}, activityId:{}", userId, activityId, e);
            return ResponseEntity.ok("系统繁忙，请稍后再试");
        }
    }

    // Sentinel限流降级方法
    public ResponseEntity<String> grabCouponBlockHandler(Long activityId, Long userId, BlockException ex) {
        return ResponseEntity.ok("活动太火爆了，请稍后再试");
    }
}

@Component
@RocketMQMessageListener(topic = "coupon-create-topic", consumerGroup = "coupon-create-consumer-group")
public class CouponCreateConsumer implements RocketMQListener<CouponMessage> {

    @Autowired
    private UserCouponService userCouponService;
    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    public void onMessage(CouponMessage message) {
        String idempotentKey = "coupon:idempotent:" + message.getUserId() + ":" + message.getActivityId();
        
        // 1. Redis幂等校验
        if (Boolean.TRUE.equals(redisTemplate.hasKey(idempotentKey))) {
            log.info("重复消息，已处理：{}", message);
            return;
        }

        try {
            // 2. 数据库唯一索引兜底（防止Redis失效）
            userCouponService.createUserCoupon(message);
            
            // 3. 记录幂等标记，过期时间7天
            redisTemplate.opsForValue().set(idempotentKey, "1", Duration.ofDays(7));
        } catch (DuplicateKeyException e) {
            // 唯一索引冲突，说明已处理过
            log.info("重复创建用户券，已跳过：{}", message);
            redisTemplate.opsForValue().set(idempotentKey, "1", Duration.ofDays(7));
        } catch (Exception e) {
            // 其他异常，抛出让MQ重试，超过重试次数进入死信队列
            log.error("创建用户券失败：{}", message, e);
            throw new RuntimeException("创建用户券失败", e);
        }
    }
}

@Configuration
public class SentinelConfig {

    @PostConstruct
    public void initHotParamRules() {
        List<ParamFlowRule> rules = new ArrayList<>();
        ParamFlowRule rule = new ParamFlowRule("grabCoupon")
            .setGrade(RuleConstant.FLOW_GRADE_QPS)
            .setCount(1000) // 全局QPS阈值
            .setParamIdx(0) // 限流第一个参数（activityId）
            .setDurationInSec(1); // 统计窗口1秒

        // 针对超级热点活动单独设置更高阈值
        ParamFlowItem item = new ParamFlowItem()
            .setObject(String.valueOf(10001)) // 活动ID
            .setClassType(String.class.getName())
            .setCount(5000);
        rule.setParamFlowItemList(Collections.singletonList(item));

        rules.add(rule);
        ParamFlowRuleManager.loadRules(rules);
    }
}

// 初始化：把总库存均分到 10 个分片
int totalStock = 100000;
int shardCount = 10;
for (int i = 0; i < shardCount; i++) {
    redisTemplate.opsForValue().set("coupon:stock:12345:" + i, totalStock / shardCount);
}

// 抢券时随机选片扣减
public Long deductWithShard(String couponId, Long userId) {
    int shard = ThreadLocalRandom.current().nextInt(10);
    String key = "coupon:stock:" + couponId + ":" + shard;
    return redisTemplate.execute(luaScript, Collections.singletonList(key), 1, userId.toString());
}