开箱即用轻量级雪花算法id生成器Java工具类

1.1 背景

在 Java后端研发过程中，对于分布式微服务来说，一般需要分布式 id生成.

这里分享一个非常好用且大多数情况下都可用的开箱即用轻量级雪花算法id生成器Java工具类。

这种方式生成的雪花算法生成器生成的唯一主键id，好处是不依赖第三方组件，轻量级，缺点是服务器的时钟不可以回拨，否则可能会造成生成的主键id冲突。

1.2 雪花算法id生成器Java工具类

雪花算法id生成器Java工具类源码

import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
 
/**
 * id自增器（雪花算法）
 * @author renjie
 * @version 1.0.0
 */
public class SnowFlakeUtils {
    private final static long twepoch = 12888349746579L;
    /**
     * 机器标识位数
     */
    private final static long workerIdBits = 5L;
    /**
     * 数据中心标识位数
     */
    private final static long datacenterIdBits = 5L;
    /**
     * 毫秒内自增位数
     */
    private final static long sequenceBits = 12L;
    /**
     * 机器ID偏左移12位
     */
    private final static long workerIdShift = sequenceBits;
    /**
     * 数据中心ID左移17位
     */
    private final static long datacenterIdShift = sequenceBits + workerIdBits;
    /**
     * 时间毫秒左移22位
     */
    private final static long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
    /**
     * sequence掩码，确保sequnce不会超出上限
     */
    private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
    /**
     * 上次时间戳
     */
    private static long lastTimestamp = -1L;
    /**
     * 序列
     */
    private long sequence = 0L;
    /**
     * 服务器ID
     */
    private long workerId = 1L;
    private static long workerMask = -1L ^ (-1L << workerIdBits);
    /**
     * 进程编码
     */
    private long processId = 1L;
    private static long processMask = -1L ^ (-1L << datacenterIdBits);
 
    private static SnowFlakeUtils snowFlakeUtils = null;
 
    static{
        snowFlakeUtils = new SnowFlakeUtils();
    }
    public static synchronized long nextId(){
        return snowFlakeUtils.getNextId();
    }
 
    private SnowFlakeUtils() {
 
        //获取机器编码
        this.workerId=this.getMachineNum();
        //获取进程编码
        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
        this.processId=Long.valueOf(runtimeMXBean.getName().split("@")[0]).longValue();
 
        //避免编码超出最大值
        this.workerId=workerId & workerMask;
        this.processId=processId & processMask;
    }
 
    public synchronized long getNextId() {
        //获取时间戳
        long timestamp = timeGen();
        //如果时间戳小于上次时间戳则报错
        if (timestamp < lastTimestamp) {
            try {
                throw new Exception("Clock moved backwards.  Refusing to generate id for " + (lastTimestamp - timestamp) + " milliseconds");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //如果时间戳与上次时间戳相同
        if (lastTimestamp == timestamp) {
            // 当前毫秒内，则+1，与sequenceMask确保sequence不会超出上限
            sequence = (sequence + 1) & sequenceMask;
            if (sequence == 0) {
                // 当前毫秒内计数满了，则等待下一秒
                timestamp = tilNextMillis(lastTimestamp);
            }
        } else {
            sequence = 0;
        }
        lastTimestamp = timestamp;
        // ID偏移组合生成最终的ID，并返回ID
        long nextId = ((timestamp - twepoch) << timestampLeftShift) | (processId << datacenterIdShift) | (workerId << workerIdShift) | sequence;
        return nextId;
    }
 
    /**
     * 再次获取时间戳直到获取的时间戳与现有的不同
     * @param lastTimestamp
     * @return 下一个时间戳
     */
    private long tilNextMillis(final long lastTimestamp) {
        long timestamp = this.timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = this.timeGen();
        }
        return timestamp;
    }
 
    private long timeGen() {
        return System.currentTimeMillis();
    }
 
    /**
     * 获取机器编码
     * @return
     */
    private long getMachineNum(){
        long machinePiece;
        StringBuilder sb = new StringBuilder();
        Enumeration<NetworkInterface> e = null;
        try {
            e = NetworkInterface.getNetworkInterfaces();
        } catch (SocketException e1) {
            e1.printStackTrace();
        }
        while (e.hasMoreElements()) {
            NetworkInterface ni = e.nextElement();
            sb.append(ni.toString());
        }
        machinePiece = sb.toString().hashCode();
        return machinePiece;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

注意事项
这个雪花算法实现是一个常见的分布式唯一ID生成器，但它也有一些潜在的问题和优化空间：

• 唯一性保证：
  • 该算法的唯一性依赖于每个节点的机器ID（workerId）和数据中心ID（processId）。如果这些ID在不同节点上配置不正确，可能导致ID冲突。
  • 唯一性还依赖于时钟同步。如果时钟回拨（Clock Drift）或不稳定，可能会导致生成的ID不唯一。
• 时钟回拨问题：
  • 该算法没有显式处理时钟回拨情况。如果系统时钟发生回拨，可能会导致生成的ID不连续，甚至出现重复。
  • 优化：您可以考虑在时钟回拨检测到时采取适当的措施，例如等待或重新生成ID。
• 长期运行问题：
  • 如果您的应用长期运行，可能会达到每毫秒生成的ID数量的限制，尤其是在高并发情况下。
  • 优化：可以根据实际需求调整位数，以提高每毫秒生成ID的上限。
• 可扩展性问题：
  • 该算法中的位数分配不一定适用于所有应用。如果您的应用需要更多的数据中心或机器节点，需要重新分配位数。
  • 优化：可以根据需求增加位数分配的灵活性，以支持更多的数据中心或机器。
• 不适用于移动设备：
  • 该算法依赖于机器ID和数据中心ID的配置，对于移动设备等无法确定唯一ID的环境不适用。
  • 优化：可以考虑在这种情况下使用其他唯一ID生成策略。
• 异常处理：
  • 该算法在出现异常情况时没有提供良好的处理机制，例如时钟回拨异常。
  • 优化：添加适当的异常处理，以确保生成的ID在异常情况下也是正确的。

• 总的来说，这个雪花算法实现在大多数情况下都能正常工作，但在特定情况下可能会出现问题。
• 优化的策略会根据应用的具体需求而变化，可以根据需要进行调整，以确保生成的ID满足唯一性、连续性和性能要求。
• 如果您需要更高级的解决方案，还可以考虑使用分布式ID生成服务或其他专用工具。