雪花算法(snowflake)笔记

最新推荐文章于 2024-07-17 11:02:53 发布

binbinxyz

最新推荐文章于 2024-07-17 11:02:53 发布

阅读量1.1k

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/binbinxyz/article/details/104012710

版权

java 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

SnowFlake概述

SnowFlake算法生成id的结果是一个64bit大小的整数，它的结构如下图：
在这里插入图片描述
算法描述：

1bit 不用。因为二进制中最高位是符号位，1表示负数，0表示正数。我们生成的id一般都使用正数，所以这个最高位固定是0，没有实际作用。。
41bit 时间戳。用来记录时间戳，毫秒级。41位可以表示2⁴¹−1个数字，如果只用来表示正整数（计算机中正数包含0），可以表示的数值范围是：0 至 2⁴¹−1，也就是说41位可以表示2⁴¹−1个毫秒的值，转化成单位年则是(2⁴¹−1)/(1000∗60∗60∗24∗365)=69年。时间位还有一个很重要的作用是可以根据时间进行排序。
10bit 用来记录工作机器id。10位的机器标识，包括5位datacenterId和5位workerId，10位的长度最多支持部署1024个节点。5位（bit）可以表示的最大正整数是2⁵−1=31，即可以用0、1、2、3、…31这32个数字，来表示不同的datecenterId或workerId
12bit 序列号，用来记录同毫秒内产生的不同id。12位（bit）可以表示的最大正整数是2¹²−1=4095，即可以用0、1、2、3、…4094这4095个数字，来表示同一机器同一时间截（毫秒)内产生的4095个ID序号

由于在Java中64bit的整数是long类型，所以在Java中SnowFlake算法生成的id就是long来存储的。
SnowFlake算法在同一毫秒内最多可以生成多少个全局唯一ID呢？只需要做一个简单的乘法：同一毫秒的ID数量 = 1024 X 4096 = 4194304。这个数字在绝大多数并发场景下都是够用的

SnowFlake作用

SnowFlake可以保证：

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

看的出来，这个算法很简洁也很简单，但依旧是一个很好的ID生成策略。其中，10位器标识符一般是5位IDC+5位machine编号，唯一确定一台机器。

Talk is cheap, show you the code

public class IdWorker {
	// 下面两个每个5位，加起来就是10位的工作机器id
	/** 5位的工作id，也是10位工作机器id的一部分 */
	private long workerId;
	/** 5位的数据id，也是10位工作机器id的一部分 */
	private long datacenterId;
	/** 12位的序列号 */
	private long sequence;

	public IdWorker(long workerId, long datacenterId, long sequence) {
		// sanity check for workerId
		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));
		}
		System.out.printf(
				"worker starting. timestamp left shift %d, datacenter id bits %d, worker id bits %d, sequence bits %d, workerid %d",
				timestampLeftShift, datacenterIdBits, workerIdBits, sequenceBits, workerId);

		this.workerId = workerId;
		this.datacenterId = datacenterId;
		this.sequence = sequence;
	}

	/** 初始时间戳 */
	private long twepoch = 1288834974657L;

	// 长度为5位
	private long workerIdBits = 5L;
	private long datacenterIdBits = 5L;
	// 最大值
	private long maxWorkerId = -1L ^ (-1L << workerIdBits);
	private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
	/** 序列号id长度 */
	private long sequenceBits = 12L;
	/** 序列号最大值 */
	private long sequenceMask = -1L ^ (-1L << sequenceBits);

	/** 工作id需要左移的位数，12位 */
	private long workerIdShift = sequenceBits;
	/** 数据id需要左移的位数，12+5=17位 */
	private long datacenterIdShift = sequenceBits + workerIdBits;
	/** 时间戳需要左移位数，12+5+5=22位 */
	private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

	/** 上次时间戳，初始值为负数 */
	private long lastTimestamp = -1L;

	public long getWorkerId() {
		return workerId;
	}

	public long getDatacenterId() {
		return datacenterId;
	}

	public long getTimestamp() {
		return System.currentTimeMillis();
	}

	/**
	 * 下一个ID生成算法
	 * 
	 * @return
	 */
	public synchronized long nextId() {
		long timestamp = timeGen();

		// 获取当前时间戳如果小于上次时间戳，则表示时间戳获取出现异常
		if (timestamp < lastTimestamp) {
			System.err.printf("clock is moving backwards.  Rejecting requests until %d.", lastTimestamp);
			throw new RuntimeException(String.format(
					"Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
		}

		// 同一毫秒内序列号自增；新的毫秒序列号从0开始。
		if (lastTimestamp == timestamp) {
			sequence = (sequence + 1) & sequenceMask;
			if (sequence == 0) {
				timestamp = tilNextMillis(lastTimestamp);
			}
		} else {
			sequence = 0;
		}

		// 将上次时间戳值刷新
		lastTimestamp = timestamp;

		/**
		 * 返回结果： (timestamp - twepoch) << timestampLeftShift) 表示将时间戳减去初始时间戳，再左移相应位数
		 * (datacenterId << datacenterIdShift) 表示将数据id左移相应位数 (workerId << workerIdShift)
		 * 表示将工作id左移相应位数 | 是按位或运算符，例如：x | y，只有当x，y都为0的时候结果才为0，其它情况结果都为1。
		 * 因为个部分只有相应位上的值有意义，其它位上都是0，所以将各部分的值进行 | 运算就能得到最终拼接好的id
		 */
		return ((timestamp - twepoch) << timestampLeftShift) | (datacenterId << datacenterIdShift)
				| (workerId << workerIdShift) | sequence;
	}

	/**
	 * 获取时间戳，并与上次时间戳比较
	 * 
	 * @param lastTimestamp
	 * @return
	 */
	private long tilNextMillis(long lastTimestamp) {
		long timestamp = timeGen();
		while (timestamp <= lastTimestamp) {
			timestamp = timeGen();
		}
		return timestamp;
	}

	/**
	 * 获取系统时间戳
	 * 
	 * @return
	 */
	private long timeGen() {
		return System.currentTimeMillis();
	}

	public static void main(String[] args) {
		IdWorker worker = new IdWorker(1, 1, 1);
		for (int i = 0; i < 30; i++) {
			System.out.println(worker.nextId());
		}
	}
}

几点需要解释一下：

获得单一机器的下一个序列号，使用Synchronized控制并发，而非CAS的方式，是因为CAS不适合并发量非常高的场景。
如果当前毫秒在一台机器的序列号已经增长到最大值4095，则使用while循环等待直到下一毫秒。
如果当前时间小于记录的上一个毫秒值，则说明这台机器的时间回拨了，抛出异常。但如果这台机器的系统时间在启动之前回拨过，那么有可能出现ID重复的危险。

another

public class SnowFlake {

	/**
	 * 起始的时间戳:这个时间戳自己随意获取，比如自己代码的时间戳
	 */
	private final static long START_STMP = 1543903501000L;

	/**
	 * 每一部分占用的位数
	 */
	private final static long SEQUENCE_BIT = 12; // 序列号占用的位数
	private final static long MACHINE_BIT = 5; // 机器标识占用的位数
	private final static long DATACENTER_BIT = 5;// 数据中心占用的位数

	/**
	 * 每一部分的最大值：先进行左移运算，再同-1进行异或运算；异或：相同位置相同结果为0，不同结果为1
	 */
	/** 用位运算计算出最大支持的数据中心数量：31 */
	private final static long MAX_DATACENTER_NUM = -1L ^ (-1L << DATACENTER_BIT);

	/** 用位运算计算出最大支持的机器数量：31 */
	private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);

	/** 用位运算计算出12位能存储的最大正整数：4095 */
	private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);

	/**
	 * 每一部分向左的位移
	 */

	/** 机器标志较序列号的偏移量 */
	private final static long MACHINE_LEFT = SEQUENCE_BIT;

	/** 数据中心较机器标志的偏移量 */
	private final static long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;

	/** 时间戳较数据中心的偏移量 */
	private final static long TIMESTMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT;

	private static long datacenterId; // 数据中心
	private static long machineId; // 机器标识
	private static long sequence = 0L; // 序列号
	private static long lastStmp = -1L;// 上一次时间戳

	/**
	 * 此处无参构造私有，同时没有给出有参构造，在于避免以下两点问题：
	 * 1、私有化避免了通过new的方式进行调用，主要是解决了在for循环中通过new的方式调用产生的id不一定唯一问题问题，因为用于
	 * 记录上一次时间戳的lastStmp永远无法得到比对； 2、没有给出有参构造在第一点的基础上考虑了一套分布式系统产生的唯一序列号应该是基于相同的参数
	 */
	private SnowFlake() {
	}

	/**
	 * 产生下一个ID
	 *
	 * @return
	 */
	public static synchronized long nextId() {
		/** 获取当前时间戳 */
		long currStmp = getNewstmp();

		/** 如果当前时间戳小于上次时间戳则抛出异常 */
		if (currStmp < lastStmp) {
			throw new RuntimeException("Clock moved backwards.  Refusing to generate id");
		}
		/** 相同毫秒内 */
		if (currStmp == lastStmp) {
			// 相同毫秒内，序列号自增
			sequence = (sequence + 1) & MAX_SEQUENCE;
			// 同一毫秒的序列数已经达到最大
			if (sequence == 0L) {

				/** 获取下一时间的时间戳并赋值给当前时间戳 */
				currStmp = getNextMill();
			}
		} else {
			// 不同毫秒内，序列号置为0
			sequence = 0L;
		}
		/** 当前时间戳存档记录，用于下次产生id时对比是否为相同时间戳 */
		lastStmp = currStmp;

		return (currStmp - START_STMP) << TIMESTMP_LEFT // 时间戳部分
				| datacenterId << DATACENTER_LEFT // 数据中心部分
				| machineId << MACHINE_LEFT // 机器标识部分
				| sequence; // 序列号部分
	}

	private static long getNextMill() {
		long mill = getNewstmp();
		while (mill <= lastStmp) {
			mill = getNewstmp();
		}
		return mill;
	}

	private static long getNewstmp() {
		return System.currentTimeMillis();
	}

}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class SnowFlakeIdGenerator {
    // 初始时间截 (2017-01-01)
    private static final long INITIAL_TIME_STAMP = 1483200000000L;

    // 机器id所占的位数
    private static final long WORKER_ID_BITS = 5L;

    // 数据标识id所占的位数
    private static final long DATACENTER_ID_BITS = 5L;

    // 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数)
    private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);

    // 支持的最大数据标识id，结果是31
    private static final long MAX_DATACENTER_ID = ~(-1L << DATACENTER_ID_BITS);

    // 序列在id中占的位数
    private final long SEQUENCE_BITS = 12L;

    // 机器ID的偏移量(12)
    private final long WORKERID_OFFSET = SEQUENCE_BITS;

    // 数据中心ID的偏移量(12+5)
    private final long DATACENTERID_OFFSET = WORKER_ID_BITS + SEQUENCE_BITS;

    // 时间截的偏移量(5+5+12)
    private final long TIMESTAMP_OFFSET = SEQUENCE_BITS + WORKER_ID_BITS + DATACENTER_ID_BITS;

    // 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095)
    private final long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS);

    // 工作节点ID(0~31)
    private long workerId;

    // 数据中心ID(0~31)
    private long datacenterId;

    // 毫秒内序列(0~4095)
    private long sequence = 0L;

    // 上次生成ID的时间截
    private long lastTimestamp = -1L;

    /**
     * 构造函数
     *
     * @param workerId     工作ID (0~31)
     * @param datacenterId 数据中心ID (0~31)
     */
    public SnowFlakeIdGenerator(long workerId, long datacenterId) {
        if (workerId > MAX_WORKER_ID || workerId < 0) {
            throw new IllegalArgumentException(String.format("WorkerID 不能大于 %d 或小于 0", MAX_WORKER_ID));
        }
        if (datacenterId > MAX_DATACENTER_ID || datacenterId < 0) {
            throw new IllegalArgumentException(String.format("DataCenterID 不能大于 %d 或小于 0", MAX_DATACENTER_ID));
        }

        this.workerId = workerId;
        this.datacenterId = datacenterId;

    }

    /**
     * 获得下一个ID (用同步锁保证线程安全)
     *
     * @return SnowflakeId
     */
    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis();
        // 如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
        if (timestamp < lastTimestamp) {
            throw new RuntimeException("当前时间小于上一次记录的时间戳！");
        }
        // 如果是同一时间生成的，则进行毫秒内序列
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & SEQUENCE_MASK;
            // sequence等于0说明毫秒内序列已经增长到最大值
            if (sequence == 0) {
                // 阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        // 时间戳改变，毫秒内序列重置
        else {
            sequence = 0L;
        }
        // 上次生成ID的时间截
        lastTimestamp = timestamp;
        // 移位并通过或运算拼到一起组成64位的ID
        return ((timestamp - INITIAL_TIME_STAMP) << TIMESTAMP_OFFSET) | (datacenterId << DATACENTERID_OFFSET)
                | (workerId << WORKERID_OFFSET) | sequence;
    }

    /**
     * 阻塞到下一个毫秒，直到获得新的时间戳
     *
     * @param lastTimestamp 上次生成ID的时间截
     * @return 当前时间戳
     */
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = System.currentTimeMillis();
        while (timestamp <= lastTimestamp) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }
}

public class Main {

    public static void main(String[] args) throws LifecycleException {
        final SnowFlakeIdGenerator idGenerator = new SnowFlakeIdGenerator(1, 1);
        // 线程池并行执行10000次ID生成
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10000; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    long id = idGenerator.nextId();
                    System.out.println(id);
                }
            });
        }
        executorService.shutdown();
    }
}

binbinxyz

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
雪花算法(snowflake)笔记

SnowFlake概述SnowFlake算法生成id的结果是一个64bit大小的整数，它的结构如下图：算法描述：1bit 不用。因为二进制中最高位是符号位，1表示负数，0表示正数。我们生成的id一般都使用正数，所以这个最高位固定是0。41bit 时间戳。用来记录时间戳，毫秒级。41位可以表示241−1个数字，如果只用来表示正整数（计算机中正数包含0），可以表示的数值范围是：0 至 24...
复制链接

扫一扫

专栏目录