分布式ID生成算法 雪花算法

1、SnowFlake算法生成id的结果是一个64bit大小的整数，它的结构如下图：

        

●  1位，不用。二进制中最高位为1的都是负数，但是我们生成的id一般都使用整数，所以这个最高位固定是0

●  41位，用来记录时间戳（毫秒）。
         ○  41位可以表示$2^{41}-1$个数字，
         ○  如果只用来表示正整数（计算机中正数包含0），可以表示的数值范围是：0 至 $2^{41}-1$，减1是因为可表示的数值范围是从0开始算的，而不是1。
         ○ 也就是说41位可以表示$2^{41}-1$个毫秒的值，转化成单位年则是$(2^{41}-1) / (1000 * 60 * 60 * 24 * 365) = 69$年

●  10位，用来记录工作机器id。
         ○  可以部署在$2^{10} = 1024$个节点，包括 5位datacenterId 和 5位workerId
         ○  5位（bit）可以表示的最大正整数是$2^{5}-1 = 31$，即可以用0、1、2、3、....31这32个数字，来表示不同的datecenterId或workerId

●  12位，***，用来记录同毫秒内产生的不同id。
         ○  12位（bit）可以表示的最大正整数是$2^{12}-1 = 4095$，即可以用0、1、2、3、....4094这4095个数字，来表示同一机器同一时间截（毫秒)内产生的4095个ID序号

由于在Java中64bit的整数是long类型，所以在Java中SnowFlake算法生成的id就是long来存储的。

SnowFlake可以保证：
        ●  所有生成的id按时间趋势递增
        ●  整个分布式系统内不会产生重复id（因为有datacenterId和workerId来做区分）

示例代码：

package icefire.demo.disSys;

/**
 * 分布式ID生成算法 雪花算法
 * 41位：时间戳
 * 10位：机器id
 * 12位：同一时间戳自增id
 * @author zhangjiaqi
 *
 */
public class SnowGUID {

	private long initTime = 1584427306000L; // "2020/03/17" 程序开始时间
	
	private long timeStampBit = 41;
	private long machineIdBit = 10;
	private long autoIdBit    = 12;
	
	private long machineId;
	private long autoId = 0;
	private long lastTime = 0;
	
	public static final SnowGUID snow = new SnowGUID(0);
	
	public SnowGUID(long machineId) {
		this.machineId = machineId;
	}
	
	public synchronized long produce() {
		while(true) {
			long timeStamp = System.currentTimeMillis() - initTime;
			
			if(lastTime != timeStamp) {
				autoId = 0;
			}
			lastTime = timeStamp;
			autoId++;
			
			if(autoId >= (1 << autoIdBit)) {
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				continue;
			}
			
			long v1 = timeStamp << (machineIdBit + autoIdBit);
			long v2 = machineIdBit << autoIdBit;
			long v3 = autoId;
			return v1 + v2 + v3;
		}
	}
}

测试：

package icefire.demo.disSys;

import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

public class Test {

	public static  ConcurrentHashMap<Long, Integer> map = new ConcurrentHashMap<Long, Integer>();
	public static  HashMap<Long, Integer> hashMap = new HashMap<Long, Integer>();
    public static AtomicInteger count = new AtomicInteger(0); 
	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			public void run() {
				while(true) {
					long id =  SnowGUID.snow.produce();
					map.put(id, 0);
					hashMap.put(id, 0);
					System.out.println("size: " + map.size() + " s: " + count.incrementAndGet() + " hashMap:" + hashMap.size());
				}
			}
		}).start();
		new Thread(new Runnable() {
			public void run() {
				while(true) {
					long id =  SnowGUID.snow.produce();
					map.put(id, 0);
					hashMap.put(id, 0);
					System.out.println("size: " + map.size() + " s: " + count.incrementAndGet() + " hashMap:" + hashMap.size());
				}
			}
		}).start();
		new Thread(new Runnable() {
			public void run() {
				while(true) {
					long id =  SnowGUID.snow.produce();
					map.put(id, 0);
					hashMap.put(id, 0);
					System.out.println("size: " + map.size() + " s: " + count.incrementAndGet() + " hashMap:" + hashMap.size());
				}
			}
		}).start();
	}

}