分布式全局不重复ID生成算法Twitter的Snowflake

雨点打透心脏的1/2处 2022-03-19 09:58 292阅读 0赞

在分布式系统中经常会使用到生成全局唯一不重复ID的情况。

### 常见的一些方式 ###

###### 1、通过DB做全局自增操作 ######

优点：简单、高效。  
缺点：大并发、分布式情况下性能比较低。

分库、分表的策略去降低DB的瓶颈，单要做到全局不重要需要提前按照一定的区域进行划分。例如：1 ~ 300000、300001 ~ 600000 等等。但这个灵活度比较低。

针对一些并发比较低的情况也可以使用类似这种方式。但大并发时不建议使用，DB很容易成为瓶颈。

###### 2、获取当前时间纳秒或毫秒数 ######

这种方式需要考虑的是在分布式集群中如果保证唯一性。

###### 3、类似UUID的生成方式 ######

生成的串比较大，不建议使用。

### Twitter的Snowflake（雪花算法） ###

/** * 名称：IdWorker.java * 描述：分布式自增长ID * 核心代码为其IdWorker这个类实现，其原理结构如下，我分别用一个0表示一位，用—分割开部分的作用： * 1||0---0000000000 0000000000 0000000000 0000000000 0 --- 00000 ---00000 ---000000000000 * 在上面的字符串中，第一位为未使用（实际上也可作为long的符号位），接下来的41位为毫秒级时间， * 然后5位datacenter标识位，5位机器ID（并不算标识符，实际是为线程标识）， * 然后12位该毫秒内的当前毫秒内的计数，加起来刚好64位，为一个Long型。 * 这样的好处是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞（由datacenter和机器ID作区分）， * 并且效率较高，经测试，snowflake每秒能够产生26万ID左右，完全满足需要。 * 64位ID (42(毫秒)+5(机器ID)+5(业务编码)+12(重复累加)) * @author Polim */
    public class IdWorker { 
        // 时间起始标记点，作为基准，一般取系统的最近时间（一旦确定不能变动）
        private final static long twepoch = 1288834974657L;
        // 机器标识位数
        private final static long workerIdBits = 5L;
        // 数据中心标识位数
        private final static long datacenterIdBits = 5L;
        // 机器ID最大值
        private final static long maxWorkerId = -1L ^ (-1L << workerIdBits);
        // 数据中心ID最大值
        private final static long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
        // 毫秒内自增位
        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;
        private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
        /* 上次生产id时间戳 */
        private static long lastTimestamp = -1L;
        // 0，并发控制
        private long sequence = 0L;
        private final long workerId;
        // 数据标识id部分
        private final long datacenterId;
        
        public IdWorker(){ 
            this.datacenterId = getDatacenterId(maxDatacenterId);
            this.workerId = getMaxWorkerId(datacenterId, maxWorkerId);
        }
        /** * @param workerId 工作机器ID * @param datacenterId 序列号 */
        public IdWorker(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;
        }
        /** * 获取下一个ID * @return id */
        public synchronized long nextId() { 
            long timestamp = timeGen();
            if (timestamp < lastTimestamp) { 
                throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
            }
    
            if (lastTimestamp == timestamp) { 
                // 当前毫秒内，则+1
                sequence = (sequence + 1) & sequenceMask;
                if (sequence == 0) { 
                    // 当前毫秒内计数满了，则等待下一秒
                    timestamp = tilNextMillis(lastTimestamp);
                }
            } else { 
                sequence = 0L;
            }
            lastTimestamp = timestamp;
            // ID偏移组合生成最终的ID，并返回ID
            long nextId = ((timestamp - twepoch) << timestampLeftShift)
                    | (datacenterId << datacenterIdShift)
                    | (workerId << workerIdShift) | sequence;
    
            return nextId;
        }
    
        private long tilNextMillis(final long lastTimestamp) { 
            long timestamp = this.timeGen();
            while (timestamp <= lastTimestamp) { 
                timestamp = this.timeGen();
            }
            return timestamp;
        }
    
        private long timeGen() { 
            return System.currentTimeMillis();
        }
    
        /** * 获取 maxWorkerId * @return id */
        protected static long getMaxWorkerId(long datacenterId, long maxWorkerId) { 
            StringBuffer mpid = new StringBuffer();
            mpid.append(datacenterId);
            String name = ManagementFactory.getRuntimeMXBean().getName();
            if (!name.isEmpty()) { 
             /* * GET jvmPid */
                mpid.append(name.split("@")[0]);
            }
          /* * MAC + PID 的 hashcode 获取16个低位 */
            return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);
        }
    
        /** * 数据标识id部分 * @return id */
        protected 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);
                }
            } catch (Exception e) { 
                System.out.println(" getDatacenterId: " + e.getMessage());
            }
            return id;
        }
    }

##### 测试类 #####

public static void main(String[] args) { 
    	// 实例化传入数字参数即可
    	IdWorker idWorker = new IdWorker(0, 0);
    	for (int i = 0; i < 100; i++) { 				
    		System.out.println(idWorker.nextId());
    	}
    }

##### 输出结果 #####

1096652560527261696
    1096652560527261697
    .....
    .....
    1096652560552427520
    1096652560552427521

可以看到数字位数是19位数。

### Spring配置方式 ###

保证每一组的`index`和`value`不一样就一定不会有重复的ID出现。

##### ================================================================================ #####

##### 感谢阅读，写得不好的地方请指教，能帮助到你是对我最好的回报，不卑不亢，加油。 #####

##### 请你记住比你优秀的一定比你努力，比你努力的人一定比你优秀。 #####

##### ================================================================================ #####