Redis Lua 脚本实现高并发库存扣减：从原子性保障到主节点宕机的数据安全

1. 读取当前剩余库存
2. 判断库存 > 0
3. 库存减 1
4. 记录该用户已抢到

// 危险！非原子操作
Long stock = redisTemplate.opsForValue().get("activity:1001:stock"); // step1
if (stock != null && stock > 0) {                                     // step2
    redisTemplate.opsForValue().decrement("activity:1001:stock");     // step3
}

-- KEYS[1]: 库存Key        activity:{activityId}:stock
-- KEYS[2]: 已抢用户集合    activity:{activityId}:users
-- ARGV[1]: 用户ID
-- ARGV[2]: 当前时间戳
​
-- 1. 检查用户是否已抢过（防重复）
if redis.call('SISMEMBER', KEYS[2], ARGV[1]) == 1 then
    return -1  -- 返回 -1 表示重复抢票
end
​
-- 2. 获取当前库存
local stock = tonumber(redis.call('GET', KEYS[1]))
​
-- 3. 判断库存是否充足
if stock == nil or stock <= 0 then
    return 0   -- 返回 0 表示库存不足
end
​
-- 4. 扣减库存
redis.call('DECR', KEYS[1])
​
-- 5. 将用户加入已抢集合
redis.call('SADD', KEYS[2], ARGV[1])
​
-- 6. 返回扣减后的剩余库存
return stock - 1

@Service
public class RedisTicketService {
​
    private final StringRedisTemplate redisTemplate;
    private final DefaultRedisScript<Long> deductScript;
​
    @PostConstruct
    public void init() {
        // 预加载 Lua 脚本（只加载一次，后续通过 SHA1 调用，减少网络传输）
        deductScript = new DefaultRedisScript<>();
        deductScript.setLocation(new ClassPathResource("scripts/deduct_stock.lua"));
        deductScript.setResultType(Long.class);
    }
​
    public TicketResult deductStock(Long activityId, Long userId) {
        String stockKey = "activity:" + activityId + ":stock";
        String usersKey = "activity:" + activityId + ":users";
​
        Long result = redisTemplate.execute(
            deductScript,
            Arrays.asList(stockKey, usersKey),
            userId.toString(),
            String.valueOf(System.currentTimeMillis())
        );
​
        if (result == null) {
            throw new SystemException("Redis 脚本执行异常");
        }
​
        if (result == -1L) {
            return TicketResult.duplicated("您已抢到该活动名额，请勿重复操作");
        }
        if (result == 0L) {
            return TicketResult.soldOut("手慢了，名额已被抢光");
        }
​
        // 扣减成功，发送 MQ 异步创建订单
        orderMQProducer.sendCreateOrder(activityId, userId);
        return TicketResult.success("抢票成功！剩余名额: " + result);
    }
}

String stockKey = "activity:{" + activityId + "}:stock";
String usersKey = "activity:{" + activityId + "}:users";
// {activityId} 是 hash tag，Redis 只对花括号内的部分计算 slot
// 同一个 activityId 的两个 Key 一定在同一个 slot

# Redis 配置
appendonly yes
appendfsync everysec           # 每秒刷盘，最多丢1秒数据
save 900 1                     # 15分钟内有1次修改则触发RDB
save 300 10                    # 5分钟内有10次修改则触发RDB
aof-use-rdb-preamble yes       # 混合持久化：RDB头+AOF尾，重启恢复更快

# sentinel.conf
sentinel monitor ticket-master 192.168.1.10 6379 2
sentinel down-after-milliseconds ticket-master 5000   # 5秒无响应判定下线
sentinel failover-timeout ticket-master 15000          # 故障转移超时15秒

抢票请求
   │
   ▼
Redis Lua 脚本扣减库存（快速通道，毫秒级响应）
   │ 扣减成功
   ▼
发送 MQ 消息（异步）
   │
   ▼
订单消费者：
   1. 在 MySQL 中创建订单（INSERT）
   2. 在 MySQL 中扣减库存（UPDATE stock SET remain = remain - 1 WHERE remain > 0）
   3. 如果 MySQL 扣减失败（remain <= 0），说明真实库存已耗尽
      → 回滚订单
      → 回补 Redis 库存（INCR）
      → 通知用户抢票失败

@Transactional
public void consumeOrderMessage(OrderMessage msg) {
    // 1. MySQL 中扣减库存（带乐观锁条件）
    int affected = activityMapper.deductStock(msg.getActivityId());

    if (affected == 0) {
        // MySQL 库存已耗尽，Redis 多扣了（极端情况）
        // 回补 Redis 库存
        redisTemplate.opsForValue().increment(
            "activity:{" + msg.getActivityId() + "}:stock");
        // 将用户从已抢集合移除
        redisTemplate.opsForSet().remove(
            "activity:{" + msg.getActivityId() + "}:users",
            msg.getUserId().toString());
        // 通知用户
        notifyService.sendTicketFailed(msg.getUserId(), "库存异常，抢票未成功，已全额退款");
        return;
    }

    // 2. 创建订单
    orderService.createOrder(msg.getActivityId(), msg.getUserId());
}

@Component
public class StockReconciliationTask {

    /**
     * 每5分钟执行一次，校验 Redis 库存与 MySQL 库存的一致性
     */
    @Scheduled(fixedRate = 300000)
    public void reconcileStock() {
        List<Activity> activeActivities = activityMapper.selectActiveActivities();

        for (Activity activity : activeActivities) {
            // MySQL 中的真实剩余库存
            int dbStock = activity.getRemainStock();

            // Redis 中的库存
            String redisKey = "activity:{" + activity.getId() + "}:stock";
            String redisStock = redisTemplate.opsForValue().get(redisKey);

            if (redisStock == null) {
                // Redis 中没有库存数据（可能是宕机后丢失），从 MySQL 恢复
                redisTemplate.opsForValue().set(redisKey, String.valueOf(dbStock));
                log.warn("活动 {} Redis 库存缺失，已从 MySQL 恢复: {}", activity.getId(), dbStock);
                continue;
            }

            int rStock = Integer.parseInt(redisStock);
            if (Math.abs(rStock - dbStock) > 2) {
                // 差异超过阈值，告警 + 以 MySQL 为准修正
                log.error("活动 {} 库存不一致！Redis={}, MySQL={}", activity.getId(), rStock, dbStock);
                redisTemplate.opsForValue().set(redisKey, String.valueOf(dbStock));
                alertService.send("库存不一致告警", "活动" + activity.getId());
            }
        }
    }
}