亿级流量电商：在“数字海啸”中，把每一次点击都变成可控的“确定性物理实验”

// 伪代码：防止缓存击穿的互斥锁逻辑
public Product getProductById(Long id) {
    // 1. 先查缓存
    String cacheKey = "product:" + id;
    Product product = redis.get(cacheKey);
    if (product != null) return product;

    // 2. 缓存失效，尝试获取分布式锁（setnx）
    String lockKey = "lock:product:" + id;
    boolean locked = redis.setnx(lockKey, "1", 30, TimeUnit.SECONDS);
    
    if (locked) {
        try {
            // 3. 拿到锁的线程去数据库查，并重建缓存
            product = db.queryProduct(id);
            redis.set(cacheKey, product, 3600, TimeUnit.SECONDS);
        } finally {
            redis.del(lockKey);
        }
    } else {
        // 4. 没拿到锁的线程不查数据库，原地等待100ms后递归重试
        Thread.sleep(100);
        return getProductById(id); 
    }
    return product;
}

// 秒杀请求入口：极速收单，绝不阻塞
public Response seckill(Long userId, Long productId) {
    // 防重入校验（略）
    // 内存级限流（略）
    
    // 核心：将请求包装为“任务票据”，丢进 RocketMQ
    SeckillMessage msg = new SeckillMessage(userId, productId, System.currentTimeMillis());
    boolean success = mqProducer.send(msg, (m) -> {
        // 哈希路由，保证同一用户的消息顺序
        m.setShardingKey(userId.toString());
    });
    
    if (success) {
        // 立即返回“排队中”，前端显示“正在拼命处理...”
        return Response.accepted("已在队列中，请稍后查询结果");
    } else {
        return Response.error("系统繁忙，请重试");
    }
}

// MQ 消费者（并发度严格控制，如 20 个线程）
@RocketMQMessageListener(consumerGroup = "order_group", consumeThreadMax = 20)
public class OrderConsumer {
    public void onMessage(SeckillMessage msg) {
        // 这里才真正扣库存、落订单、走完整事务
        // 即便处理慢，MQ 的堆积机制也能确保数据不丢失
        orderService.createOrder(msg);
    }
}

-- 扣减库存的原子操作（利用数据库行锁）
UPDATE inventory 
SET available_stock = available_stock - #{buyCount}, 
    sold_stock = sold_stock + #{buyCount}
WHERE product_id = #{productId} 
  AND available_stock >= #{buyCount}  -- 防止超卖的血肉条件
  AND version = #{version};           -- 乐观锁版本号

// 应用层配合：基于 Redis 的防重 Token 机制
public Order createOrder(OrderDTO dto) {
    // 1. 前置处理：使用 setIfAbsent 防重（唯一请求 ID）
    String tokenKey = "order_token:" + dto.getRequestId();
    Boolean isNew = redis.opsForValue().setIfAbsent(tokenKey, "1", 24, TimeUnit.HOURS);
    if (!isNew) {
        throw new RepeatSubmitException("请勿重复提交");
    }
    
    // 2. 执行数据库更新（行锁在这里生效）
    try {
        int affected = inventoryMapper.decreaseStock(dto);
        if (affected == 0) {
            // 更新行数为0，说明条件不满足，抛异常回滚
            throw new StockShortageException("库存不足或版本冲突");
        }
        // 3. 生成订单...
    } catch (Exception e) {
        // 异常时删除 Token，允许用户重试
        redis.delete(tokenKey);
        throw e;
    }
}

// 最简路由算法（基于用户 ID 取模）
public class ShardingRouter {
    // 假设 16 个库，每库 64 张表 = 1024 张物理表
    private static final int DB_COUNT = 16;
    private static final int TABLE_COUNT = 64;

    public static ShardResult route(Long userId) {
        // 取绝对值防止负数
        long hash = Math.abs(userId.hashCode());
        int dbIndex = (int) (hash % DB_COUNT);
        int tableIndex = (int) ((hash / DB_COUNT) % TABLE_COUNT);
        return new ShardResult(dbIndex, tableIndex);
    }
}

// 查询时动态拼接表名
public Order getOrder(Long userId, Long orderId) {
    ShardResult shard = route(userId);
    // 指定库和表：ds_3.order_45
    String tableName = "order_" + shard.getTableIndex();
    // 走分库分表中间件（如 ShardingSphere）自动路由
    return orderMapper.selectOne(userId, tableName, orderId);
}