Twitter的snowflake算法改进

爱被打了一巴掌 2023-06-21 15:23 19阅读 0赞

Twitter的snowflake算法是在分布式系统中一种自增ID的算法，ID能够按照时间有序生成并且可以做到全局唯一。

算法生成的是Long类型的id，一个Long类型占8个字节，每个字节占8比特，也就是说一个Long类型占64个比特（0和1）。

Twitter是这样分配的：正数位（占1比特）+时间戳（占41比特）+机器id（占5比特）+数据中心（占5比特）+自增值（占12比特），总共64比特组成的一个Long类型。

*  正数位（占1比特）：由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，由于id一般是正数，所以这个位一般都是0
 *  时间戳（占41个比特）：毫秒数，大约可以使使用69年
 *  机器id（占5个比特）：即2的5次方等于32个机器
 *  数据中心id（占5个比特）：即2的5次方等于32个数据中心
 *  自增值（占12比特）：2的12次方等于4096。也就是说每毫秒最多可以生成4096个id，如果cpu生产id的速度大于每毫秒4096个，那么需要使线程进行等待到下一毫秒，重新计数获取自增值。

SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。

snowflake算法有一个弊端，每毫秒重新计数，空闲时间会浪费很多id空间。针对空闲时间会浪费很多id空间的改进办法：咱们可以把时间戳的单位改为秒。使用31个比特的时间戳（秒），节约了10个比特，2的31次方等于2,147,483,648秒，约为69年。然后我们把节约出来的10个比特交给自增值，此时自增值（12+10=22比特），即2的22次方等于4,194,304。

改进前的snowflake算法结构为：正数位（占1比特）+时间戳（占41比特）+机器id（占5比特）+数据中心id（占5比特）+自增值（占12比特）

改进后的snowflake算法结构为：正数位（占1比特）+时间戳（占31比特）+机器id（占5比特）+数据中心id（占5比特）+自增值（占22比特）

改进后的优点：避免空闲时间会浪费很多id空间，支持每秒生成419万个id。

改进后的实现代码如下：

public class SnowflakeIdWorker2nd {
    	/** 开始时间截 (2019-01-01) */
    	private final long twepoch = 1546272000000L;
    
    	/** 机器id所占的位数 */
    	private final long workerIdBits = 5L;
    
    	/** 数据标识id所占的位数 */
    	private final long datacenterIdBits = 5L;
    
    	/** 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数) */
    	private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
    
    	/** 支持的最大数据标识id，结果是31 */
    	private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
    
    	/** 序列在id中占的位数 */
    	private final long sequenceBits = 22L;
    
    	/** 机器ID向左移22位 */
    	private final long workerIdShift = sequenceBits;
    
    	/** 数据标识id向左移27位(22+5) */
    	private final long datacenterIdShift = sequenceBits + workerIdBits;
    
    	/** 时间截向左移32位(5+5+22) */
    	private final long timestampLeftShift = sequenceBits + workerIdBits
    			+ datacenterIdBits;
    
    	/** 生成序列的掩码，这里为4194303 */
    	private final long sequenceMask = -1L ^ (-1L << sequenceBits);
    
    	/** 工作机器ID(0~31) */
    	private long workerId;
    
    	/** 数据中心ID(0~31) */
    	private long datacenterId;
    
    	/** 秒内序列(0~4194303) */
    	private long sequence = 0L;
    
    	/** 上次生成ID的时间截 */
    	private int lastTimestamp = -1;
    
    	// ==============================Constructors=====================================
    	/**
    	 * 构造函数
    	 * 
    	 * @param workerId
    	 *            工作ID (0~31)
    	 * @param datacenterId
    	 *            数据中心ID (0~31)
    	 */
    	public SnowflakeIdWorker2nd(long workerId, long datacenterId) {
    		if (workerId > maxWorkerId || workerId < 0) {
    			throw new IllegalArgumentException(String.format(
    					"worker Id can't be greater than %d or less than 0",
    					maxWorkerId));
    		}
    		if (datacenterId > maxDatacenterId || datacenterId < 0) {
    			throw new IllegalArgumentException(String.format(
    					"datacenter Id can't be greater than %d or less than 0",
    					maxDatacenterId));
    		}
    		this.workerId = workerId;
    		this.datacenterId = datacenterId;
    	}
    
    	// ==============================Methods==========================================
    	/**
    	 * 获得下一个ID (该方法是线程安全的)
    	 * 
    	 * @return SnowflakeId
    	 */
    	public synchronized long nextId() {
    		int timestamp = timeGen();
    
    		// 如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
    		if (timestamp < lastTimestamp) {
    			throw new RuntimeException(String.format(
    					"Clock moved backwards.  Refusing to generate id for %d milliseconds",
    					lastTimestamp - timestamp));
    		}
    
    		// 如果是同一时间生成的，则进行秒内序列
    		if (lastTimestamp == timestamp) {
    			sequence = (sequence + 1) & sequenceMask;
    			// 秒内序列溢出
    			if (sequence == 0) {
    				// 阻塞到下一个秒,获得新的时间戳
    				timestamp = tilNextMillis(lastTimestamp);
    			}
    		}
    		// 时间戳改变，秒内序列重置
    		else {
    			sequence = 0L;
    		}
    
    		// 上次生成ID的时间截
    		lastTimestamp = timestamp;
    
    		// 移位并通过或运算拼到一起组成64位的ID
    		return ((timestamp - twepoch) << timestampLeftShift) //
    				| (datacenterId << datacenterIdShift) //
    				| (workerId << workerIdShift) //
    				| sequence;
    	}
    
    	/**
    	 * 阻塞到下一个秒，直到获得新的时间戳
    	 * 
    	 * @param lastTimestamp
    	 *            上次生成ID的时间截
    	 * @return 当前时间戳
    	 */
    	protected int tilNextMillis(int lastTimestamp) {
    		int timestamp = timeGen();
    		while (timestamp <= lastTimestamp) {
    			timestamp = timeGen();
    		}
    		return timestamp;
    	}
    
    	/**
    	 * 返回以秒为单位的当前时间
    	 * 
    	 * @return 当前时间(秒)
    	 */
    	protected int timeGen() {
    		String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
    		return Integer.valueOf(timestamp);
    	}
    
    	// ==============================Test=============================================
    	/** 测试 */
    	public static void main(String[] args) {
    		SnowflakeIdWorker2nd idWorker = new SnowflakeIdWorker2nd(0, 0);
    		for (int i = 0; i < 1000; i++) {
    			long id = idWorker.nextId();
    			System.out.println(Long.toBinaryString(id));//转为Bit，前面的0省略掉
    			System.out.println(id);
    		}
    	}
    }