【黑马点评日记03】秒杀场景必备：全局唯一ID生成策略及秒杀下单逻辑

全局唯一ID = 时间戳（高位） + 序列号（低位）

java

// 每天一个 key
String key = "order:id:" + LocalDate.now();
Long id = redisTemplate.opsForValue().increment(key);

31位时间戳差值（秒） + 32位自增序列

java

// 起始时间戳（秒级）
private static final long START_TIMESTAMP = 1672531200L; // 2023-01-01
private static final int COUNT_BITS = 32;

public long nextId(String keyPrefix) {
    // 1. 时间戳差值（秒）
    long now = System.currentTimeMillis() / 1000;
    long timestamp = now - START_TIMESTAMP;
    
    // 2. 序列号（每天或每小时重置，避免太长）
    String date = LocalDate.now().toString();
    String key = "icr:" + keyPrefix + ":" + date;
    Long count = redisTemplate.opsForValue().increment(key);
    
    // 3. 组合
    return (timestamp << COUNT_BITS) | count;
}

服务器A：订单1、订单2、订单3...
服务器B：订单1、订单2、订单3...  ← 重复了！
服务器C：订单1、订单2、订单3...  ← 重复了！

1765440000 + 5 = 1765440005  ← 这样会破坏结构，无法拆回原来的两个数

高8位存放时间戳差值，低8位存放序列号

时间戳 = 10  →  二进制：00001010
序列号 = 3   →  二进制：00000011

第一步：时间戳左移8位
00001010 00000000   （时间戳占用了高8位，低8位全是0）

第二步：序列号不动
00000000 00000011   （序列号只在低8位）

第三步：按位或（合并）
00001010 00000011   ← 最终ID
高8位↑     ↑低8位
（时间戳） （序列号）

java

// 配置常量
private static final long START_TIMESTAMP = 1672531200L; // 2023-01-01
private static final int COUNT_BITS = 32;  // 序列号占用32位

public long nextId(String keyPrefix) {
    // 1. 获取当前时间戳差值（秒级）
    long now = System.currentTimeMillis() / 1000;
    long timestamp = now - START_TIMESTAMP;  // 比如 = 123456789
    
    // 2. 获取序列号（Redis自增）
    String key = "icr:" + keyPrefix + ":" + LocalDate.now();
    Long sequence = redisTemplate.opsForValue().increment(key);  // 比如 = 5
    
    // 3. 位运算合并
    // timestamp 左移 32 位，空出低32位给 sequence
    long id = (timestamp << COUNT_BITS) | sequence;
    
    return id;
}

timestamp = 123456789
sequence = 5

1. timestamp << 32
   123456789 × 2^32 = 530,242,313,337,176,064

2. 按位或 sequence
   530,242,313,337,176,064 | 5 = 530,242,313,337,176,069
   
最终ID就是这个超大整数

java

// 从最终ID中拆出时间戳
long timestamp = id >> 32;  // 右移32位，抛弃低32位

// 从最终ID中拆出序列号
long sequence = id & 0xFFFFFFFFL;  // 按位与，保留低32位

java

long now = System.currentTimeMillis() / 1000;  // 当前秒级时间戳
long id = (now << 32) | sequence;

1,765,440,000 × 2^32 = 7,581,000,000,000,000,000（约 7.58 × 10^18）

 private StringRedisTemplate stringRedisTemplate;
    public RedisIdWork(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

java

String key = "icr:" + keyPrefix + ":" + date;
Long sequence = redisTemplate.opsForValue().increment(key);

bash

# 2025年4月21日，订单业务的序列号
key = "icr:order:2025-04-21"
value = 1  # 第1次调用自增 → 变成2 → 3 → 4...

# 2025年4月21日，优惠券业务的序列号  
key = "icr:coupon:2025-04-21"
value = 1  # 独立计数，互不影响

# 第二天的序列号（key不同）
key = "icr:order:2025-04-22"
value = 1  # 从1重新开始

java

nextId("order")   → key = "icr:order:2025-04-21"
nextId("coupon")  → key = "icr:coupon:2025-04-21"

java

String date = LocalDate.now().toString(); // 每天变化

4月21日的 key：icr:order:2025-04-21

4月22日的 key：icr:order:2025-04-22

bash

# 查看今天生成了多少个订单ID
GET icr:order:2025-04-21

# 删除昨天的key（释放内存）
DEL icr:order:2025-04-20

java

// 格式：业务:子业务:参数
"order:detail:1001"        // 订单详情
"user:info:888"            // 用户信息  
"icr:order:2025-04-21"     // 自增计数器
"lock:seckill:100"         // 分布式锁

调用 nextId("order")
    ↓
生成 key = "icr:order:2025-04-21"
    ↓
Redis.INCR("icr:order:2025-04-21")
    ↓
第一次调用：key 不存在 → 创建并设为 1
第二次调用：key 存在   → 自增为 2
第三次调用：           → 自增为 3
    ↓
返回 sequence = 3
    ↓
与时间戳合并 → 最终 ID

// 32位最大 4,294,967,295（约42亿）
// 如果一天超过42亿次自增怎么办？

java

// 批量获取 ID，减少网络开销
public List<Long> batchNextId(String keyPrefix, int batchSize) {
    String key = "icr:" + keyPrefix + ":" + LocalDate.now();
    Long start = redisTemplate.opsForValue().increment(key, batchSize);
    List<Long> ids = new ArrayList<>();
    for (int i = 0; i < batchSize; i++) {
        long timestamp = getTimestamp();
        long sequence = start - batchSize + i + 1;
        ids.add((timestamp << COUNT_BITS) | sequence);
    }
    return ids;
}

# Redis 配置（保证 ID 不丢失）
save 900 1     # 15分钟至少1次修改则RDB
appendonly yes # 开启AOF
appendfsync everysec # 每秒刷盘

sql

CREATE TABLE `tb_voucher` (
  `id` bigint(20) NOT NULL COMMENT '主键',
  `shop_id` bigint(20) DEFAULT NULL COMMENT '商铺id',
  `title` varchar(255) NOT NULL COMMENT '优惠券标题',
  `sub_title` varchar(255) DEFAULT NULL COMMENT '副标题',
  `rules` varchar(1024) DEFAULT NULL COMMENT '使用规则',
  `pay_value` bigint(10) NOT NULL COMMENT '支付金额',
  `actual_value` bigint(10) NOT NULL COMMENT '抵扣金额',
  `type` tinyint(1) NOT NULL COMMENT '类型 0-普通 1-秒杀',
  `status` tinyint(1) DEFAULT '1' COMMENT '状态 1-上架 2-下架',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE,
  PRIMARY KEY (`id`)
);

sql

CREATE TABLE `tb_seckill_voucher` (
  `voucher_id` bigint(20) NOT NULL COMMENT '优惠券id',
  `stock` int(11) NOT NULL COMMENT '库存',
  `begin_time` datetime NOT NULL COMMENT '开始时间',
  `end_time` datetime NOT NULL COMMENT '结束时间',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE,
  PRIMARY KEY (`voucher_id`)
);

java

@Data
public class VoucherAddDTO {
    private String title;           // 优惠券标题
    private String subTitle;        // 副标题
    private String rules;           // 使用规则
    private Integer payValue;       // 支付金额（分）
    private Integer actualValue;    // 抵扣金额（分）
    private Integer type;           // 0-普通 1-秒杀
    
    // 秒杀特有字段
    private Integer stock;          // 库存
    private LocalDateTime beginTime;// 开始时间
    private LocalDateTime endTime;  // 结束时间
}

java

@RestController
@RequestMapping("/voucher")
public class VoucherController {
    
    @Autowired
    private IVoucherService voucherService;
    
    /**
     * 添加普通优惠券
     */
    @PostMapping("/add")
    public Result addVoucher(@RequestBody Voucher voucher) {
        voucherService.save(voucher);
        return Result.ok(voucher.getId());
    }
    
    /**
     * 添加秒杀优惠券（重点）
     */
    @PostMapping("/seckill/add")
    public Result addSeckillVoucher(@RequestBody Voucher voucher) {
        voucherService.addSeckillVoucher(voucher);
        return Result.ok();
    }
}

java

@Service
public class VoucherServiceImpl extends ServiceImpl<VoucherMapper, Voucher> 
        implements IVoucherService {
    
    @Autowired
    private SeckillVoucherMapper seckillVoucherMapper;
    
    @Override
    @Transactional  // 事务保证两张表同时成功或失败
    public void addSeckillVoucher(Voucher voucher) {
        // 1. 保存普通优惠券信息
        voucher.setType(1);  // 类型：秒杀券
        boolean saved = save(voucher);
        if (!saved) {
            throw new RuntimeException("添加优惠券失败");
        }
        
        // 2. 保存秒杀特有信息
        SeckillVoucher seckillVoucher = new SeckillVoucher();
        seckillVoucher.setVoucherId(voucher.getId());  // 关联普通券ID
        seckillVoucher.setStock(voucher.getStock());
        seckillVoucher.setBeginTime(voucher.getBeginTime());
        seckillVoucher.setEndTime(voucher.getEndTime());
        
        int inserted = seckillVoucherMapper.insert(seckillVoucher);
        if (inserted != 1) {
            throw new RuntimeException("添加秒杀信息失败");
        }
        
        // 3. 可选：将库存同步到 Redis（为秒杀做准备）
        String key = "seckill:stock:" + voucher.getId();
        stringRedisTemplate.opsForValue().set(key, voucher.getStock().toString());
    }
}

java

@Override
@Transactional
public void addSeckillVoucher(Voucher voucher) {
    // 1. 参数校验
    if (voucher.getTitle() == null || voucher.getTitle().isEmpty()) {
        throw new IllegalArgumentException("优惠券标题不能为空");
    }
    
    if (voucher.getPayValue() <= 0 || voucher.getActualValue() <= 0) {
        throw new IllegalArgumentException("金额必须大于0");
    }
    
    if (voucher.getPayValue() <= voucher.getActualValue()) {
        throw new IllegalArgumentException("支付金额必须大于抵扣金额");
    }
    
    // 2. 秒杀券特有校验
    if (voucher.getType() == 1) {
        if (voucher.getStock() == null || voucher.getStock() <= 0) {
            throw new IllegalArgumentException("秒杀券库存必须大于0");
        }
        
        LocalDateTime now = LocalDateTime.now();
        if (voucher.getBeginTime().isBefore(now)) {
            throw new IllegalArgumentException("开始时间不能早于当前时间");
        }
        
        if (voucher.getEndTime().isBefore(voucher.getBeginTime())) {
            throw new IllegalArgumentException("结束时间不能早于开始时间");
        }
    }
    
    // 3. 保存数据...
}

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {

    @Resource
    private ISeckillVoucherService iSeckillVoucherService;
    @Resource
    private RedisIdWork redisIdWork;
    /**
     * 下单秒杀优惠卷
     * @param voucherId 优惠券id
     * @return
     */
    @Transactional
    public Result seckillVoucher(Long voucherId) {
        //提交优惠卷id，查询优惠卷
        SeckillVoucher voucher = iSeckillVoucherService.getById(voucherId);
        //判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
            return Result.fail("秒杀尚未开始");
        }
        //秒杀是否终止
        if (voucher.getEndTime().isBefore(LocalDateTime.now())){
            return Result.fail("秒杀已经结束");
        }
        //判断库存
        if(voucher.getStock()<1){
            return Result.fail("库存不足");
        }
        //扣减库存
        Boolean success=iSeckillVoucherService.update().setSql("stock=stock-1").eq("voucher_id",voucherId).update();
        if (!success){
            return Result.fail("库存不足");
        }
        //创建订单
        VoucherOrder voucherOrder = new VoucherOrder();
        // 5.1 生成全局唯一订单ID
        long orderId = redisIdWork.nextId("order");
        voucherOrder.setId(orderId);
        // 5.2 设置用户ID（从ThreadLocal获取当前登录用户）
        Long userId = UserHolder.getUser().getId();
        voucherOrder.setUserId(userId);
        // 5.3 设置优惠券ID
        voucherOrder.setVoucherId(voucherId);
        // 5.4 设置支付状态（未支付）
        voucherOrder.setStatus(0);
        // 5.5 设置创建时间
        voucherOrder.setCreateTime(LocalDateTime.now());
        // 保存订单
        save(voucherOrder);

        // ========== 6. 返回订单ID ==========
        return Result.ok(orderId);
        
    }
}