目录
一、使用线程安全的类——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或者AtomicLong
public 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 {
@Autowired
private 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对象中的属性
@Override
public 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的值，如果没有配置，则默认为1
private long nodeId;
// afterPropertiesSet方法初始化Bean对象中的属性
@Override
public 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=1234563.创建实体类、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的值，如果没有配置，则默认为1
private long nodeId;
// afterPropertiesSet方法初始化Bean对象中的属性
@Override
public 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的最大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;
}
// 生成级次编码需要借助流水号的方法
public long getLongKey(String type) {
return getSerialNum(type, 1); // 1表示每次从数据库中 获取1个流水号
}
}
数据库结果：
