当前位置：首页 > news >正文

分布式主键生成服务

news 2025/11/22 2:24:59

一、使用线程安全的类——AtomicInteger或者AtomicLong

二、主键生成最简单写法(不推荐)

三、主键生成方法一：Long型id生成——雪花算法

四、主键生成方法二：流水号

(一)流水号概述

(二)添加配置

1.pom.xml

2.application.properties

3.创建实体类、Mapper，修改启动类

(三)流水号生成基础写法

1.基础代码

2.基础代码存在的问题

3.基础代码优化

4.使用httpd进行并发测试

(四)流水号生成批量拿取id

五、主键生成方法三：级次编码

一、使用线程安全的类——AtomicInteger或者AtomicLong

import java.util.concurrent.atomic.AtomicInteger;public class TestService {public Integer count = 0;// 多个线程同时对同一个数字进行操作的时候，使用AtomicInteger或者AtomicLongpublic AtomicInteger atomicInteger = new AtomicInteger(0);public static void main(String[] args) {// 创建两个线程，每个线程对count进行10000次自增操作TestService testService = new TestService();Thread t1 = new Thread(() -> {for (int i = 0; i < 10000; i++) {
//                primaryService.count++;
//                primaryService.atomicInteger.incrementAndGet();testService.atomicInteger.getAndIncrement();}});Thread t2 = new Thread(() -> {for (int i = 0; i < 10000; i++) {
//                primaryService.count++;
//                primaryService.atomicInteger.incrementAndGet();testService.atomicInteger.getAndIncrement();}});t1.start();t2.start();// 使用 t1.join() 和 t2.join() 来确保主线程// （即 main 方法所在的线程）会等待 t1 和 t2 执行完毕后再继续执行try {t1.join();t2.join();} catch (InterruptedException e) {e.printStackTrace();}
//        System.out.println("count=" + primaryService.count); // count=10671// 如果你只是关心最终的 count 值，而不是每次操作的具体返回值，那么 incrementAndGet() 和 getAndIncrement() 的结果看起来是一样的，因为它们都会正确地对 count 进行自增操作。但是，// 如果你需要依赖返回值来进行某些逻辑判断或处理，那么选择哪个方法就很重要了。System.out.println("atomicInteger=" + testService.atomicInteger); // count=10671}
}

二、主键生成最简单写法(不推荐)

创建一个项目，添加依赖：

<parent><artifactId>spring-boot-starter-parent</artifactId><groupId>org.springframework.boot</groupId><version>2.6.11</version>
</parent>
<dependencies>    <!--注意：所有的依赖不可以随意添加，不需要的依赖不要添加，宁可少不能多--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>
</dependencies>
oject>

Service：

@Service
public class PrimaryService {// 生成主键最简单方式private AtomicLong num = new AtomicLong(0);public Long getId() {return num.incrementAndGet();}
}

Controller：

@RestController
public class PrimaryController {@Autowiredprivate PrimaryService primaryService;@GetMapping("/getId")public Long getId() {return primaryService.getId();}
}

存在的问题：该方法虽然能够保证多线程下的安全性，但是每次重启服务都会从1开始获取。

因此，new AtomicLong(0)的初始值不应该设置为0，可以设置为当前毫秒值。正确写法：

@Service
public class PrimaryService implements InitializingBean {// 生成主键最简单方式private AtomicLong num;// 初始化Bean对象中的属性@Overridepublic void afterPropertiesSet() throws Exception {num = new AtomicLong(System.currentTimeMillis());}public Long getId() {return num.incrementAndGet();}
}

无论重启多少次，拿到的id永远是越来越大。

但是使用时间戳作为主键也有问题：

当主键生成服务部署成集群时，启动主键生成服务集群，生成的时间戳是一样的，这样当user服务第一次拿取和第二次拿取的主键值很有可能一样。针对这一问题的解决方案就是：雪花算法。

三、主键生成方法一：Long型id生成——雪花算法

雪花算法的含义：用不同的位，表示不同的含义。

1个字节是8位，以int类型为例，该数据类型是4个字节，所以是4*8=32位。

long类型是8个字节，就是8*8=64位

例如：

0 1000000 00000000 00000000 00000000

第一位表示符号位第2位如果是0表示男，如果是1表示女

这里，我们将时间戳转为二进制：

public static void main(String[] args) {System.out.println(Long.toBinaryString(1740485559705L));
}

结果：

1 10010101 00111101 00000110 00000101 10011001

不够64位，左边补0：

00000000 00000000 00000001 10010101 00111101 00000110 00000101 10011001

使用雪花算法分成三段：

第1位是符号位，0表示正数

第2位到第7位表示机器号，如果都占满，则为1111111，转为十进制为：127台机器

一个普通的微服务架构，最多127台机器已经足够了

剩下的56位，表示当前时间，一个 56 位时间戳（以毫秒为单位，从 Unix 纪元开始计时）最多能表示到大约 公元 3020 年 左右。如果今天是 2025 年 2 月 25 日，则从今天开始，56 位时间戳可以覆盖未来约 千年的时间范围，也足够了。

其他的雪花算法形式：

位运算Tips：

按位或(|) ：当两个相应的二进制位中至少有一个是1时，结果为1；否则为0。

例如：0101 | 0111 = 0111

按位异或(^)：当两个相应的二进制位不同时，结果为1；相同则为0。

例如：0101 ^ 0111 = 0010

以下图的时间戳为例：如果机器号为1，那么先将机器号左移56位

左移后的数据，与当前时间戳进行位运算，最终，机器号和时间戳就可以成功拼接。

@Service
public class PrimaryService implements InitializingBean {// 生成主键最简单方式private AtomicLong baseId;// 将机器号作为配置@Value("${node.id:1}") // 表示配置文件中node.id的值，如果没有配置，则默认为1private long nodeId;// afterPropertiesSet方法初始化Bean对象中的属性@Overridepublic void afterPropertiesSet() throws Exception {long now = System.currentTimeMillis();// 机器号先左移56位，再和时间戳做或运算，就是初始id值baseId = new AtomicLong(nodeId << 56 | now);}public Long getId() {return baseId.incrementAndGet();}
}

http://localhost:8080/getId结果：72059334530093401

返回的Id不宜过大，因为前端的js的number无法容纳这么长的值，因此需要转为字符串返回给前端，否则会精度丢失。

四、主键生成方法二：流水号

(一)流水号概述

流水号示例：000001、000002、000003或者202502250001、202502250002

流水号的生成必须按顺序来，第一次生成的是000001，那么第二次生成的必须是000002，这种生成方式就不能借助时间戳了，需要借助数据库来生成。

创建一张表：

create table if not exists pk.`pk|_seed`
(type    varchar(30) not null comment '业务类型：user，contract，order'primary key,value   int         null comment '最新值',version int         null comment '版本号，做乐观锁'
);

type表示不同的业务类型

(二)添加配置

1.pom.xml

<dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>3.5.2</version>
</dependency>
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.29</version>
</dependency>

注意：当下载依赖的时候，依赖树中存在依赖，但是左侧的依赖没有，重启IDEA即可，这是IDEA的bug。

2.application.properties

server.port=8080
#数据库
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.157.102:3306/pk?useSSL=false
spring.datasource.username=root
spring.datasource.password=123456

3.创建实体类、Mapper，修改启动类

@TableName("pk_seed")
public class PkSeed {@TableId // 标识该字段是主键private String type;private Integer value;private Integer version;public String getType() {return type;}public void setType(String type) {this.type = type;}public Integer getValue() {return value;}public void setValue(Integer value) {this.value = value;}public Integer getVersion() {return version;}public void setVersion(Integer version) {this.version = version;}
}

public interface PkSeedMapper extends BaseMapper<PkSeed> {
}

@SpringBootApplication
@MapperScan("com.javatest.mapper")
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class,args);}
}

我们不使用mybatisplus自带的雪花算法，而是自定义，可以控制某一个位是什么含义。

(三)流水号生成基础写法

1.基础代码

PrimaryService类中添加：

// 流水号生成基础写法
@Autowired
private PkSeedMapper pkSeedMapper;
public String getSerialNum(String type) {if (!StringUtils.hasText(type)) {throw new RuntimeException("type is null");}int result = 0;PkSeed pkSeed = pkSeedMapper.selectById(type);if (pkSeed == null) {pkSeed = new PkSeed();pkSeed.setType(type);pkSeed.setValue(1);pkSeed.setVersion(1);pkSeedMapper.insert(pkSeed);result = pkSeed.getValue(); // 返回最新的值} else {// 如果根据主键查询到，则更新result = pkSeed.getValue() + 1;pkSeedMapper.updateValue(result, type, pkSeed.getVersion());}return String.format("%06d", result);
}

public interface PkSeedMapper extends BaseMapper<PkSeed> {@Update("update pk_seed set value = #{value} , version = version + 1 where type = #{type} and version = #{version}")void updateValue(int value, String type, int version);
}

重启服务，浏览器访问：

user服务：

order也是一样：

2.基础代码存在的问题

上述代码存在的问题：多线程问题。

当有两个线程同时执行更新语句updateValue方法时，A线程和B线程同时查到version=5，A线程先执行，version改为6，接下来B线程后执行，因为B线程要根据version=5的条件修改value，但是version此时已经是6了，所以会执行失败。这就是数据库乐观锁。

失败会直接中断程序，我们可以将失败的情况进行循环。

3.基础代码优化

@Autowired
private PkSeedMapper pkSeedMapper;
public String getSerialNum(String type) {if (!StringUtils.hasText(type)) {throw new RuntimeException("type is null");}// 流水号的最新值int result = 0;int updateCount = 0;int times = 0;do {if (times > 10) {throw new RuntimeException("服务器繁忙，请稍候再试");}PkSeed pkSeed = pkSeedMapper.selectById(type);if (pkSeed == null) {pkSeed = new PkSeed();pkSeed.setType(type);pkSeed.setValue(1);pkSeed.setVersion(1);pkSeedMapper.insert(pkSeed);result = pkSeed.getValue(); // 返回最新的值updateCount = 1;} else {// 如果根据主键查询到，则更新updateCount = pkSeedMapper.updateValue(pkSeed.getValue() + 1, type, pkSeed.getVersion());if (updateCount == 1) {result = pkSeed.getValue() + 1;}}// 每次更新都增加一次次数times++;} while (updateCount == 0); // 更新失败，重新执行循环return String.format("%06d", result);
}

注意：这里流水号的长度，也就是String.format("%06d", result);中的6，也应该由参数传入，这里简写了。

public interface PkSeedMapper extends BaseMapper<PkSeed> {@Update("update pk_seed set value = #{value} , version = version +1 where type = #{type} and version = #{version}")int updateValue(int value, String type, int version);
}

4.使用httpd进行并发测试

安装一个并发测试工具：httpd

 yum -y install httpd

使用ab测试： ab -c 10 -n 10 http://localhost/

解释：

-c 10：一次发送10个请求
-n 10：请求的总数量是10
-c 10 -n 100：表示发送测试10次，每次并发10个请求

测试前：

[root@localhost soft]# ab -c 10 -n 10 http://192.168.0.16:8080/getSerialNum?type=user

测试后：

一次性使用50个并发请求：

[root@localhost soft]# ab -c 50 -n 50 http://192.168.0.16:8080/getSerialNum?type=user

因此，优化后的也有线程问题。我们继续进行优化。

(四)流水号生成批量拿取id

根据上面的代码，在同时有更多请求时，虽然使用了数据库乐观锁保证了数据的安全，但是不能保证所有的sql都执行成功。每次从数据库获取id，都要进行IO操作，且不一定每次都成功，如果添加100个id，就要修改100次数据库，效率低下

优化思路：每次从数据库拿到200个id，把这200个数字放到内存中，之后的请求都可以从内存中拿到id，不需要修改数据库。每次拿1个，数据库中的id就+1，以此类推，每次从数据库拿200个，数据库中的id就+200。

200就是最新值，也就是最大值。根据最大值可以计算出最小值，min=max-num+1，num就是要获取的id个数，当前最大值和要获取的id个数都是200，那么min=200-200+1=1。拿到了最大值和最小值，中间的200个数字就能计算出来了。

以此类推，当id初始值为1684时，要一次性从数据库中拿412个id，那么最大值就是1684+412=2096，最小值=2096-412+1=1685。拿到了最大值和最小值，中间的412个数字就能计算出来了。

这412个数字不需要都放在内存中，只需要将最大值和最小值放在map中即可，直接查询内存即可。每次拿取最小值都+1，直到最小值>最大值，说明内存中累计存放的412个数字用完了，再去数据库中一次性取412个id，循环往复。

每次从数据库拿到200个id，放到内存中，具体操作是：
a. 每次让数据库中的value+200，得到一个最大的id = max
b. 根据 max 计算出最小的id, 计算公式 min = max - count + 1
c. 把最大 id 和最小 id 放到 map 中，
d. 如果有人请求获取id,先判断内存中是否有，如果有就从内存获取，
每次获取都让 min++，直到 min 的值 > max时，下一次请求，再次从数据库中查出200个id，放到内存中

private static final int count = 200; // 一次性从数据库获取的流水号数量
// 最大id的map key是type，value是当前type的最大id
private static ConcurrentHashMap<String, AtomicLong> maxIdMap = new ConcurrentHashMap<>();
// 最小id的map
private static ConcurrentHashMap<String, AtomicLong> minIdMap = new ConcurrentHashMap<>();
public String callGetSerialNum(String type) {AtomicLong maxValue = maxIdMap.get(type);AtomicLong minValue = minIdMap.get(type);synchronized (type.intern()) {if (minValue == null || maxValue == null || minValue.get() > maxValue.get()) {// 从数据库中获取新的值=最大值long max = getSerialNum(type, count);// 计算最小值long min = max - count + 1;minIdMap.put(type, new AtomicLong(min));maxIdMap.put(type, new AtomicLong(max));}return String.format("%06d", minIdMap.get(type).getAndIncrement()); // 返回给前端最小值}
}
// 流水号生成基础写法
@Autowired
private PkSeedMapper pkSeedMapper;
public long getSerialNum(String type, int count) {if (!StringUtils.hasText(type)) {throw new RuntimeException("type is null");}// 流水号的最新值int result = 0;int updateCount = 0;int times = 0;do {if (times > 10) {throw new RuntimeException("服务器繁忙，请稍候再试");}PkSeed pkSeed = pkSeedMapper.selectById(type);if (pkSeed == null) {pkSeed = new PkSeed();pkSeed.setType(type);pkSeed.setValue(count);pkSeed.setVersion(1);pkSeedMapper.insert(pkSeed);result = pkSeed.getValue(); // 返回最新的值updateCount = 1;} else {// 如果根据主键查询到，则更新updateCount = pkSeedMapper.updateValue(pkSeed.getValue() + count, type, pkSeed.getVersion());if (updateCount == 1) {result = pkSeed.getValue() + count;}}// 每次更新都增加一次次数times++;} while (updateCount == 0); // 更新失败，重新执行循环return result;
}

@GetMapping("/getSerialNum")
public String callGetSerialNum(String type) {return primaryService.callGetSerialNum(type);
}

删除user那一行：重启项目，浏览器访问

高并发请求也没有错误，并且时间更短了

ab -c 100 -n 100 http://192.168.0.16:8080/getSerialNum?type=user

五、主键生成方法三：级次编码

PrimaryController：

@GetMapping("/getCode")
public String getCode(String type, String parentCode, String rule) {return GradeCodeGenerator.getNextCode(type, parentCode, rule);
}

import com.javatest.domain.GradeCodeRule;import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;/*** 级次编码生成工具*/
public class GradeCodeGenerator {//级次编码规则缓存private static ConcurrentMap<String, GradeCodeRule> codeRuleMap = new ConcurrentHashMap<>();static PrimaryService primaryService;/*** 例如：2|2|2|2* 根据父编码获取下一个子编码* parentCode=01            第一次调用返回:0101，第二次调用返回:0102* parentCode=null || ""    第一次调用返回:01，第二次调用返回:02** @param codeRule   编码规则* @param parentCode 父编码 可以为空* @param type       编码类型：业务名称* @return*/public static String getNextCode(String type, String parentCode, String codeRule) {if (!codeRuleMap.containsKey(codeRule)) {codeRuleMap.putIfAbsent(codeRule, new GradeCodeRule(codeRule));}return createCode(codeRuleMap.get(codeRule), parentCode, type);}private static String createCode(GradeCodeRule gradeCodeRule, String parentCode, String type) {parentCode = parentCode == null || parentCode.length() == 0 ? "" : parentCode;int parentGrade = gradeCodeRule.getCodeGrade(parentCode);//父编码级次if (parentGrade < 0) {throw new IllegalArgumentException("parentCode(" + parentCode + ")跟codeRule(" + gradeCodeRule.getRule() + ")不匹配");}if (parentGrade >= gradeCodeRule.getMaxGradeCount()) {throw new IllegalArgumentException(parentCode + "已经是最末级编码，无法获取子编码！");}
//        int parentGradeLength = gradeCodeRule.getGradeLength(parentGrade);int subCodeSectionLength = gradeCodeRule.getSectionLength(parentGrade + 1);//子编码末级片段长度long nextSubCode = primaryService.getLongKey(type + "-" + gradeCodeRule.getRule() + "-" + parentCode);String nextSubCodeStr = String.format("%0" + subCodeSectionLength + "d", nextSubCode);if (nextSubCodeStr.length() > subCodeSectionLength) {throw new IllegalArgumentException(parentCode + "的下一级编码已经用完！");}StringBuilder codeBuilder = new StringBuilder(parentCode);codeBuilder.append(nextSubCodeStr);return codeBuilder.toString();}static void setPrimaryKeyService(PrimaryService ps) {primaryService = ps;}}

package com.javatest.domain;import java.util.Arrays;
import java.util.StringTokenizer;/*** 级次编码规则实体*/
public class GradeCodeRule {private static final String regex = "([1-9]\\d{0,}\\|{0,1})+";/*** 编码规则，例：2|2|2* 表示：一共有3级，每级的长度为2*/private String rule;/*** 各级分段长度，例：2|2|2* 则：[2,2,2]*/private int[] codeSection = null;/*** 各级编码长度，例：2|2|2* 则：[2,4,6]*/private int[] codeLength = null;/**完整编码长度*/private int fullGradeLength;public GradeCodeRule(String rule){checkRule(rule);this.rule = rule;parseRule(rule);}private void parseRule(String rule) {StringTokenizer st = new StringTokenizer(rule,"|");int count = st.countTokens();codeSection = new int[count];codeLength = new int[count];int index = 0;fullGradeLength = 0;try {while (st.hasMoreTokens()) {codeSection[index] = Integer.parseInt(st.nextToken());fullGradeLength += codeSection[index];codeLength[index++] = fullGradeLength;}} catch (Exception e) {throw new IllegalArgumentException("请提供正确的级次编码规则，例如：2|2|2|2，表示：一共有4级，每级的长度为2");}}/*** 得到编码第grade级片段的长度。<br/>* 如编码规则为"2/3/2/3"，则：<br/>* 2级编码片段长度为3，<br/>* 3级编码片段长度为2。<br/>* @param grade int 1:代表第一级，依次类推* @return int*/public int getSectionLength(int grade) {if (grade <= 0) {return 0;} else {return codeSection[--grade];}}/*** 获取编码级次* 如编码规则为"2|2|2"，则：<br>* 编码"1010"的级次为2，<br>* 编码"10101010"的级次为-1，表示code跟编码规则不匹配，<br>* @param code* @return 编码级次*/public int getCodeGrade(String code) {if(code==null || code.length()==0) return 0;int index = Arrays.binarySearch(codeLength, code.length());return index >=0 ? index+1 : -1;}/*** 验证编码规则是否符合规范* @param rule*/public void checkRule(String rule) {if(!rule.matches(regex)){throw new IllegalArgumentException(rule+"：不正确，请提供正确的级次编码规则，例如：2|2|2|2，表示：一共有4级，每级的长度为2");}}/*** 得到最大编码级次* @return 最大编码级次*/public int getMaxGradeCount(){return codeSection.length;}public String getRule() {return rule;}public void setRule(String rule) {this.rule = rule;}public static void main(String[] args) {new GradeCodeRule("2,3,4");}
}

@Service
public class PrimaryService implements InitializingBean {// 初始id值private AtomicLong baseId;// 将机器号作为配置@Value("${node.id:1}") // 表示配置文件中node.id的值，如果没有配置，则默认为1private long nodeId;// afterPropertiesSet方法初始化Bean对象中的属性@Overridepublic void afterPropertiesSet() throws Exception {long now = System.currentTimeMillis();// 机器号先左移56位，再和时间戳做或运算，就是初始id值baseId = new AtomicLong(nodeId << 56 | now);GradeCodeGenerator.setPrimaryKeyService(this); // todo}public Long getId() {return baseId.incrementAndGet();}private static final int count = 200; // 一次性从数据库获取的流水号数量// 最大id的map key是type，value是当前type的最大idprivate static ConcurrentHashMap<String, AtomicLong> maxIdMap = new ConcurrentHashMap<>();// 最小id的mapprivate static ConcurrentHashMap<String, AtomicLong> minIdMap = new ConcurrentHashMap<>();public String callGetSerialNum(String type) {AtomicLong maxValue = maxIdMap.get(type);AtomicLong minValue = minIdMap.get(type);synchronized (type.intern()) {if (minValue == null || maxValue == null || minValue.get() > maxValue.get()) {// 从数据库中获取新的值=最大值long max = getSerialNum(type, count);// 计算最小值long min = max - count + 1;minIdMap.put(type, new AtomicLong(min));maxIdMap.put(type, new AtomicLong(max));}return String.format("%06d", minIdMap.get(type).getAndIncrement()); // 返回给前端最小值}}// 流水号生成基础写法@Autowiredprivate PkSeedMapper pkSeedMapper;public long getSerialNum(String type, int count) {if (!StringUtils.hasText(type)) {throw new RuntimeException("type is null");}// 流水号的最新值int result = 0;int updateCount = 0;int times = 0;do {if (times > 10) {throw new RuntimeException("服务器繁忙，请稍候再试");}PkSeed pkSeed = pkSeedMapper.selectById(type);if (pkSeed == null) {pkSeed = new PkSeed();pkSeed.setType(type);pkSeed.setValue(count);pkSeed.setVersion(1);pkSeedMapper.insert(pkSeed);result = pkSeed.getValue(); // 返回最新的值updateCount = 1;} else {// 如果根据主键查询到，则更新updateCount = pkSeedMapper.updateValue(pkSeed.getValue() + count, type, pkSeed.getVersion());if (updateCount == 1) {result = pkSeed.getValue() + count;}}// 每次更新都增加一次次数times++;} while (updateCount == 0); // 更新失败，重新执行循环return result;}// 生成级次编码需要借助流水号的方法public long getLongKey(String type) {return getSerialNum(type, 1); // 1表示每次从数据库中 获取1个流水号}
}