snowflake算法

1、snowflake算法ID生成器介绍

snowflake 是 twitter 开源的一个分布式ID 生成器

 

2、为什么使用snowflake

(1) 主键自增弊端:不是全局id,当多表合并、构建数据仓库、进行数据分析、会导致主键冲突

(2) uuid或guid弊端:数据量过大

(3)全局redis生成弊端:内存开销大、网络开销大

(4)snowflake解决上述问题、效率高、经测试每秒可产生26万个id

 

3、生成原理

(1)采用64位二进制数结构

(2)第1位不用,保留

(3)后41位为时间戳、可支持69年跨度

(4)后5位为机器id

(5)后5位为业务id

(6)后12为毫秒内计算器产生的序列数(每毫秒产生2的12方个id)

 

4、使用方式

(1)拷入源码(工具类)

package com.test.snowflake;

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

//雪花算法代码实现
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 begreater 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
    */
    public synchronized long nextId() {
        long timestamp = timeGen();
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(String.format("Clock moved backwards. Refusingto 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();
    }
    /**
    * <p>
    * 获取 maxWorkerId
    * </p>
    */
    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);
    }
    /**
    * <p>
    * 数据标识id部分
    * </p>
    */
    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;
    }
}

 

(2)测试

项目中work对象建议托管spring容器

IdWorker work = new IdWorker();
long id = work.nextId();
System.out.println(id);

 

转载于:https://www.cnblogs.com/dehigher/p/10100077.html

<think>我们正在讨论Snowflake算法的实现和用途。根据引用内容,Snowflake算法是Twitter开源的一种分布式ID生成方案,它生成的是一个64位的整数,通常称为雪花ID。这个ID由时间戳、机器ID(或数据中心ID)和序列号组成。###Snowflake算法原理Snowflake算法的核心思想是将一个64位的整数分成几个部分:1.**符号位(1位)**:始终为0,表示正数。2.**时间戳(41位)**:记录生成ID的时间戳(毫秒级),通常是从一个自定义的起始时间(称为epoch)开始计算的。41位的时间戳可以使用大约69(因为$2^{41}\approx2.2e12$毫秒,约等于69)。3.**数据中心ID(5位)**:可以表示最多$2^5=32$个数据中心。4.**机器ID(5位)**:每个数据中心内可以表示最多$2^5=32$台机器。5.**序列号(12位)**:同一机器同一毫秒内生成的序列号,每毫秒可以生成$2^{12}=4096$个唯一ID。因此,整个ID的结构可以用以下方式表示:$$ID=(timestamp\ll22)|(datacenter\_id\ll17)|(worker\_id\ll12)|sequence$$###实现步骤1.**确定起始时间戳(epoch)**:一般设置为系统开始使用的时间,比如`2020-01-0100:00:00`。2.**获取当前时间戳**:计算当前时间与起始时间戳的差值(毫秒)。3.**处理同一毫秒内的并发**:如果同一毫秒内生成多个ID,则递增序列号(序列号范围0~4095)。如果序列号用尽,则等待至下一毫秒。4.**处理时钟回拨**:如果检测到当前时间小于上一次生成ID的时间(即时钟回拨),则需要采取策略,如等待或抛出异常。###代码实现(简化版)以下是一个简化版的Snowflake算法实现(使用Python):```pythonimporttimeclassSnowflake:def__init__(self,datacenter_id,worker_id,epoch=1577836800000):#epoch:2020-01-01self.datacenter_id=datacenter_idself.worker_id=worker_idself.epoch=epochself.sequence=0self.last_timestamp=-1def_current_time(self):returnint(time.time()*1000)-self.epochdefnext_id(self):timestamp=self._current_time()iftimestamp<self.last_timestamp:raiseException("Clockmovedbackwards!")iftimestamp==self.last_timestamp:self.sequence=(self.sequence+1)&0xFFF#12位序列号,最大4095ifself.sequence==0:#当前毫秒序列号用完,等待下一毫秒whiletimestamp<=self.last_timestamp:timestamp=self._current_time()else:self.sequence=0self.last_timestamp=timestamp#组合各部分return(timestamp<<22)|(self.datacenter_id<<17)|(self.worker_id<<12)|self.sequence```###用途Snowflake算法主要用于分布式系统中生成全局唯一的ID,具有以下特点:-**趋势递增**:由于时间戳在高位,生成的ID整体上是递增的,有利于数据库索引。-**高性能**:本地生成,不需要网络开销。-**可排序**:ID按时间顺序生成。-**避免中心化依赖**:不像数据库自增ID或Redis自增那样依赖中心化的服务。###注意事项-**时钟回拨**:由于依赖机器时钟,如果时钟回拨(例如NTP同步导致时间回调),可能导致生成的ID重复。因此需要处理时钟回拨问题(如等待时钟追回或使用备用时钟)。-**机器ID分配**:需要确保数据中心ID和机器ID在分布式系统中是唯一的,通常通过配置中心或环境变量分配。###相关问题§§相关问题§§1.如何解决Snowflake算法中的时钟回拨问题?2.Snowflake算法中的数据中心ID和机器ID如何分配才能保证全局唯一?3.Snowflake算法与其他分布式ID生成算法(如UUID、数据库自增ID)相比有什么优缺点?4.在实际项目中,如何测试Snowflake算法的性能和唯一性?</think>### Snowflake算法详解 #### 算法原理 Snowflake算法是Twitter开源的分布式ID生成方案,核心原理是将64位整数划分为4个部分: $$ID = \underbrace{\text{符号位}}_{1位} \| \underbrace{\text{时间戳}}_{41位} \| \underbrace{\text{数据中心ID}}_{5位} \| \underbrace{\text{机器ID}}_{5位} \| \underbrace{\text{序列号}}_{12位}$$ 1. **时间戳(41位)** 记录生成ID时的毫秒级时间,从自定义起始时间(epoch)计算。最大可表示时间范围: $$T_{max} = \frac{2^{41}}{1000 \times 60 \times 60 \times 24 \times 365} \approx 69$$ 例如起始时间设为2020-01-01,可用至2089。 2. **数据中心ID + 机器ID(各5位)** 支持$2^{10}=1024$台机器($2^5 \times 2^5$),需人工配置确保全局唯一。 3. **序列号(12位)** 同一毫秒内的自增序号,每毫秒可生成$2^{12}=4096$个ID。 #### 核心优势 1. **趋势递增**:时间戳高位保证ID有序性,利于数据库索引 2. **高吞吐量**:单机每秒可生成26万ID(理论极限4096/ms) 3. **去中心化**:无需网络请求,本地生成ID 4. **低碰撞率**:通过时间戳+机器ID+序列号三重保障唯一性 #### 关键实现 ```python import time class Snowflake: def __init__(self, datacenter_id, worker_id, epoch=1577836800000): # epoch=2020-01-01 self.datacenter_id = datacenter_id self.worker_id = worker_id self.epoch = epoch self.sequence = 0 self.last_timestamp = -1 def next_id(self): timestamp = self._current_ms() # 时钟回拨处理 if timestamp < self.last_timestamp: raise Exception("Clock moved backwards!") # 同一毫秒内生成 if timestamp == self.last_timestamp: self.sequence = (self.sequence + 1) & 0xFFF # 12位序列号 if self.sequence == 0: # 当前毫秒序列号耗尽 timestamp = self._wait_next_ms(self.last_timestamp) else: self.sequence = 0 self.last_timestamp = timestamp # 组合ID (64位) return ((timestamp - self.epoch) << 22) | \ (self.datacenter_id << 17) | \ (self.worker_id << 12) | \ self.sequence def _current_ms(self): return int(time.time() * 1000) def _wait_next_ms(self, last): current = self._current_ms() while current <= last: current = self._current_ms() return current ``` #### 典型应用场景 1. **分布式数据库主键**:MySQL分库分表时的全局唯一ID 2. **消息队列消息ID**:Kafka/RabbitMQ的消息标识 3. **订单号生成**:电商系统保证订单号全网唯一 4. **日志追踪ID**:微服务架构中的请求链路追踪 #### 时钟回拨问题解决方案 1. **短暂回拨**:等待时钟同步(如NTP服务完成校准) 2. **严重回拨**: - 启用备用ID生成器(如数据库序列) - 扩展时间戳存储位(如百度uid-generator方案) - 记录最后生成时间戳,拒绝服务直到时钟恢复 > 美团Leaf方案对Snowflake改进:将序列号前置为时间差序列,支持更高并发[^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值