Redis全局唯一ID

全局ID生成器#

订单表使用数据库自增ID存在一些问题：

ID的规律性太明显，容易暴露业务数据量
分库分表后，不同表可能生成重复ID
受单表数据量和单库写入能力的限制

全局ID生成器，是一种在分布式系统下用来生成全局唯一ID的工具，一般要满足下列特性：

唯一性
高可用
高性能
递增性
安全性

为了增加ID的安全性，不直接使用Redis自增的数值，而是拼接时间戳等其它信息。

ID的组成#

64位long类型表示：

符号位：1 bit，固定为0
时间戳：31 bit，以秒为单位，大约可以使用68年
序列号：32 bit，使用Redis自增值生成

1
0 | 31位时间戳 | 32位序列号

生成公式：

1
return timestamp << COUNT_BITS | count;

使用相对时间戳而不是完整时间戳，可以减少时间戳占用的位数。

Redis自增策略#

Redis Key按照“业务类型+日期”划分：

1
icr:order:2026:07:09
2
icr:order:2026:07:10

这样可以让不同业务使用不同计数器，并且能够按天统计订单量。

Redis的INCR命令是原子操作，多线程并发执行时不会生成重复序号。

代码中的计数器实际上是按天递增，因此同一个Key在一天内不能超过2^32 - 1。

RedisIdWorker.java#

1
@Component
2
public class RedisIdWorker {
3

4
    // 开始时间戳
5
    private static final long BEGIN_TIMESTAMP = 1783555200L;
6
    // 序列号的位数
7
    private static final int COUNT_BITS = 32;
8

9
    private StringRedisTemplate stringRedisTemplate;
10

11
    public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
12
        this.stringRedisTemplate = stringRedisTemplate;
13
    }
14

15
    public long nextId(String keyPrefix) {
16
        // 1.生成时间戳
17
        LocalDateTime now = LocalDateTime.now();
18
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
19
        long timestamp  = nowSecond - BEGIN_TIMESTAMP;
20
        // 2.生成序列号
21
        // 2.1获取当前日期，精确到日
22
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
23
        long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);
24
        // 3.拼接并返回
25
        return timestamp << COUNT_BITS | count;
26
    }
27
    public static void main(String[] args) {
28
        LocalDateTime time = LocalDateTime.of(2026, 7, 9, 0, 0, 0);
29
        long second = time.toEpochSecond(ZoneOffset.UTC);
30
        System.out.println(second);
31
    }
32
}

HmDianPingApplicationTests.java#

1
@Resource
2
private RedisIdWorker redisIdWorker;
3

4
private ExecutorService es = Executors.newFixedThreadPool(500);
5

6
@Test
7
void testIDWorker() throws InterruptedException {
8
    CountDownLatch latch = new CountDownLatch(300);
9

10
    Runnable task = () -> {
11
        try {
12
            for (int i = 0; i < 100; i++) {
13
                long id = redisIdWorker.nextId("order");
14
                System.out.println("id= " + id);
15
            }
16
        } finally {
17
            latch.countDown();
18
        }
19
    };
20

21
    long begin = System.currentTimeMillis();
22

23
    for (int i = 0; i < 300; i++) {
24
        es.submit(task);
25
    }
26

27
    latch.await();
28

29
    long end = System.currentTimeMillis();
30

31
    System.out.println("time = " + (end - begin));
32

33
    es.shutdown();
34
}

全局ID常见实现还有：

UUID
数据库自增
Redis自增
Snowflake雪花算法

优惠券添加#

数据库使用两张表保存优惠券信息：

tb_voucher保存优惠券基本信息，例如优惠金额、使用规则、折扣信息和店铺ID。

tb_seckill_voucher保存秒杀库存、秒杀开始时间和秒杀结束时间。只有秒杀优惠券才需要保存这些信息。

VoucherController.java#

1
@RestController
2
@RequestMapping("/voucher")
3
public class VoucherController {
4

5
    @Resource
6
    private IVoucherService voucherService;
7

8
    /**
9
     * 新增秒杀券
10
     * @param voucher 优惠券信息，包含秒杀信息
11
     * @return 优惠券id
12
     */
13
    @PostMapping("seckill")
14
    public Result addSeckillVoucher(@RequestBody Voucher voucher) {
15
        voucherService.addSeckillVoucher(voucher);
16
        return Result.ok(voucher.getId());
17
    }
18
}

VoucherOrderServiceImpl.java#

1
@Override
2
@Transactional
3
public Result seckillVoucher(Long voucherId) {
4
    // 1.查询优惠卷
5
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
6
    // 2.判断秒杀是否开始
7
    if (voucher.getBeginTime().isAfter(LocalDateTime.now())) {
8
        // 尚未开始
9
        return Result.fail("秒杀尚未开始:");
10
    }
11
    // 3.判断秒杀时候已经结束
12
    if (voucher.getEndTime().isBefore(LocalDateTime.now())) {
13
        return Result.fail("秒杀已经结束:");
14
    }
15
    // 4.判断库存是否充足
16
    if (voucher.getStock()<1) {
17
        // 库存不足
18
        return Result.fail("库存不足");
19
    }
20
    // 5.扣减库存
21
    boolean success = seckillVoucherService.update()
22
            .setSql("stock = stock - 1")
23
            .eq("voucher_id", voucherId)
24
            .update();
25
    if(!success) {
26
        // 扣减失败
27
        return Result.fail("库存不足");
28
    }
29
    // 6.创建订单
30
    VoucherOrder voucherOrder = new VoucherOrder();
31
    // 6.1 订单id
32
    long orderId = redisIdWorker.nextId("order");
33
    voucherOrder.setId(orderId);
34
    // 6.2 用户id
35
    Long userId = UserHolder.getUser().getId();
36
    voucherOrder.setUserId(userId);
37
    // 6.3 代金劵id
38
    voucherOrder.setVoucherId(voucherId);
39
    save(voucherOrder);
40
    // 7 返回订单
41
    return Result.ok(orderId);
42
}

商品超卖#

原因是查询库存、判断库存和扣减库存不是一个不可分割的原子操作。

悲观锁#

悲观锁认为线程安全问题一定会发生，因此操作共享数据前先获取锁，使线程串行执行。

常见实现：

synchronized
Lock
数据库排他锁

优点是实现简单、安全性直观；缺点是线程需要等待，并发性能相对较低。

乐观锁#

乐观锁不直接加锁，而是在更新数据时判断数据是否已经被其他线程修改。

常见方式：

版本号法
CAS法
使用库存本身作为判断条件

版本号法：

1
UPDATE tb_seckill_voucher
2
SET stock = stock - 1,
3
    version = version + 1
4
WHERE voucher_id = ?
5
  AND version = ?;

秒杀库存只需要保证库存不小于0，可以使用stock > 0作为更新条件：

VoucherOrderServiceImpl.java#

1
// 5.扣减库存
2
boolean success = seckillVoucherService.update()
3
        .setSql("stock = stock - 1")
4
        .eq("voucher_id", voucherId).gt("stock",0)
5
        .update();
6
if(!success) {
7
    // 扣减失败
8
    return Result.fail("库存不足");
9
}

一人一单#

需求：同一个用户只能购买同一种优惠券一次。

单机环境加锁#

VoucherOrderServiceImpl.java#

1
Long userId = UserHolder.getUser().getId();
2
synchronized(userId.toString().intern()) {
3
    // 获取代理对象(事物)
4
    IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
5
    return proxy.createVoucherOrder(voucherId);
6
}

锁对象使用用户ID，能够使同一用户的请求互斥，同时允许不同用户并发下单。

创建订单#

VoucherOrderServiceImpl.java#

1
@Transactional
2
public Result createVoucherOrder(Long voucherId) {
3
    // 一人一单
4
    Long userId = UserHolder.getUser().getId();
5
    // 查询订单
6
    int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
7
    // 判断是否存在
8
    if (count > 0) {
9
        // 用户已经购买过了
10
        return Result.fail("用户已经购买一次");
11
    }
12

13
    // 5.扣减库存
14
    boolean success = seckillVoucherService.update()
15
            .setSql("stock = stock - 1") // set stock = stock - 1
16
            .eq("voucher_id", voucherId).gt("stock",0) // where id = ? and stock = ?
17
            .update();
18
    if(!success) {
19
        // 扣减失败
20
        return Result.fail("库存不足");
21
    }
22

23
    // 6.创建订单
24
    VoucherOrder voucherOrder = new VoucherOrder();
25
    // 6.1 订单id
26
    long orderId = redisIdWorker.nextId("order");
27
    voucherOrder.setId(orderId);
28
    // 6.2 用户id
29
    voucherOrder.setUserId(userId);
30
    // 6.3 代金劵id
31
    voucherOrder.setVoucherId(voucherId);
32
    save(voucherOrder);
33
    // 7 返回订单
34
    return Result.ok(orderId);
35
}

HmDianPingApplication.java#

1
// 启动类
2
@EnableAspectJAutoProxy(exposeProxy = true)
3
@MapperScan("com.hmdp.mapper")
4
@SpringBootApplication
5
public class HmDianPingApplication {
6

7
    public static void main(String[] args) {
8
        SpringApplication.run(HmDianPingApplication.class, args);
9
    }
10
}

xml#

1
<dependency>
2
    <groupId>org.aspectj</groupId>
3
    <artifactId>aspectjweaver</artifactId>
4
</dependency>

数据库唯一索引兜底#

即使业务代码已经加锁，也建议在数据库中增加唯一索引：

1
ALTER TABLE tb_voucher_order
2
ADD CONSTRAINT uk_user_voucher
3
UNIQUE (user_id, voucher_id);

唯一索引是“一人一单”的最后一道防线，可以防止程序异常、锁失效或重复消息造成重复订单。

集群环境中的锁失效问题#

集群环境下，请求可能分别进入JVM1和JVM2。每个JVM都有自己的锁监视器，因此两个线程都可能获得各自JVM中的锁。

synchronized只能保证单个JVM内部互斥，不能解决集群环境中的并发问题。

音乐

I'm Aron

音乐

全局ID生成器#

ID的组成#

Redis自增策略#

RedisIdWorker.java#

HmDianPingApplicationTests.java#

优惠券添加#

VoucherController.java#

VoucherOrderServiceImpl.java#

商品超卖#

悲观锁#

乐观锁#

VoucherOrderServiceImpl.java#

一人一单#

单机环境加锁#

VoucherOrderServiceImpl.java#

创建订单#

VoucherOrderServiceImpl.java#

HmDianPingApplication.java#

xml#

数据库唯一索引兜底#

集群环境中的锁失效问题#

评论区

音乐

文章目录