java雪花算法生成id源码分析_java生成雪花id

最近自己也研究了雪花算法的生成原理，大概知道它是如何生成的。
1.首先雪花算法生成的64位的二进制数据，为long类型。
其基本结构如下：
第一部分：最高位位0，代表生成的id为一个正数。
第二部分：41位的毫秒级时间戳(41位的长度可以使用69年)
第三部分：10位机器码，包括高5位的数据中心id，以及低5位的workerId.（10位的长度最多支持部署1024个节点）
第四部分：12位序列号，按计数从0开始递增，在同一个机器，同一个毫秒最多可生成2的12次方，总共4096个id.

雪花算法生成的id基本按照时间进行递增，效率较高，不会有生成id的冲突，
即使在并发条件下，也不会产生重复的id，因为其内部有做限制，当在同一个机器同个毫秒内并发数超过4096时，那么代码内会进行阻塞，不会生成新的id,直到下一个毫秒。

2.我自己也手写过雪花算法生成代码，里面使用了很多位运算。
代码如下:

import java.lang.management.ManagementFactory;
import java.net.InetAddress;
import java.net.NetworkInterface;

public class IdWorker {
	
	// 时间起始标记点，作为基准，一般取系统的最近时间（一旦确定不能变动）
	private static long initTimestamp=1288834974657L;
	/* 上次生产id时间戳 */
	private static long lastTimestamp=-1L;
	// 机器标识位数
	private static long workerIdBits=5L;
	// 数据中心标识位数
	private static long datacenterIdBits=5L;
	// 机器ID最大值
	private static long maxWorkerId=~(-1L<<workerIdBits);
	// 数据中心ID最大值
	private static long maxDatacenterId=~(-1L<<datacenterIdBits);
	// 毫秒内自增位
	private static long sequenceBits=12L;
	
	private static long sequenceMask=~(-1L<<sequenceBits);
	//机器id
	private long workerId;
	// 数据标识id部分
	private long datacenterId;
	// 0，并发控制
	private long sequence=0L;
	// 机器ID偏左移12位
	private static long workerIdShift=sequenceBits;
	 // 数据中心ID左移17位
	private static long datacenterShift=sequenceBits+workerIdBits;
	 // 时间毫秒左移22位
	private static long timestampShift=sequenceBits+workerIdBits+datacenterIdBits;
	
	
	public IdWorker() {
		this.datacenterId=getDatacenterId(maxDatacenterId);
		this.workerId=getWorkerId(datacenterId, maxWorkerId);
	}
	public IdWorker(long datacenterId,long workerId) {
		if(datacenterId>maxDatacenterId || datacenterId<0) {
			throw new IllegalArgumentException(String.format("datacenterId can't be rather than %d or less than 0", maxDatacenterId));
		}
		if(workerId>maxWorkerId || workerId<0) {
			throw new IllegalArgumentException(String.format("workerId can't be rather than %d or less than 0", maxWorkerId));
		}
		this.datacenterId=datacenterId;
		this.workerId=workerId;
	}
	public synchronized long nextId() {
		long timestamp=timeZone();
		if(timestamp<lastTimestamp) {
			throw new RuntimeException(String.format("clock moved backwards.Refusing generate id for %d millseconds", (timestamp-lastTimestamp)));
		}
		if(timestamp==lastTimestamp) {
			sequence=(sequence+1)&sequenceMask;
			if(sequence==0) {
				timestamp=utiNextMill(lastTimestamp);
			}
		}else {
			sequence=0L;
		}
		lastTimestamp=timestamp;
		
		return ((timestamp-initTimestamp)<<timestampShift) | (datacenterId<<datacenterShift) | (workerId<<workerIdShift) | sequence;
	}
	private long utiNextMill(long lastTimestamp) {
		long timestamp=timeZone();
		while(timestamp<=lastTimestamp) {
			timestamp=timeZone();
		}
		return timestamp;
	}
	private long timeZone() {
		return System.currentTimeMillis();
	}
	public static long getWorkerId(long datacenterId,long maxWorkerId) {
		StringBuilder myid=new StringBuilder();
		myid.append(datacenterId);
		String name=ManagementFactory.getRuntimeMXBean().getName();
		if(!name.isEmpty()) {
			myid.append(name.split("@")[0]);
		}
		return (myid.toString().hashCode() & 0xffff)%(maxWorkerId+1);
	}
	public static long getDatacenterId(long maxDatacenterId) {
		long id=0L;
		try {
			InetAddress ip=InetAddress.getLocalHost();
			NetworkInterface network=NetworkInterface.getByInetAddress(ip);
			if(network==null) {
				id=1L;
			}else {
				byte[] mac=network.getHardwareAddress();
				id=((0x000000FF&(long)mac[mac.length-1]) | (0x0000FF00&(((long)mac[mac.length-2])<<8)))>>6;
				id=id%(maxDatacenterId+1);
			}
			return id;
		}catch (Exception e) {
		}
		return id;
	}
	public static void main(String[] args) {
		IdWorker idWorker=new IdWorker();
		long id=idWorker.nextId();
		System.err.println(id);
	}
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

总结
优点：雪花算法提供了一个很好的设计思想，雪花算法生成的ID是趋势递增，生成ID的性能也是非常高的，而且可以根据自身业务特性分配bit位，非常灵活。
缺点：雪花算法强依赖机器时钟，如果机器上时钟回拨，会导致id重复。如果恰巧回退前生成过一些ID，而时间回退后，生成的ID就有可能重复。