4-1】衍生sonwflake的学习（Twitter开源分布式ID算法）

1 sonwflake简介

   互联网快速发展的今天，分布式应用系统已经见怪不怪，在分布式中，我们需要各种各样的ID，既然是ID那么必然是要保证全局唯一，除此以外，不同的业务还需要不同的特性，比如像并发巨大的业务要求ID生成率高，吞吐大；比如某些银行类业务，需要按每日日期制定交易流水号；又比如我们希望用户的ID是随机的，无序的，纯数字的，且位数长度小于10位的。等等，不同的业务场景需要的ID特性各不一样，于是，衍生了各种ID生成器，但是大多数利用数据库控制ID的生成，性能受数据库并发能力限制，那么有没有一款不需要依赖任何中间接(如数据库，分布式缓存)的ID生成器尼？ 今天，给大家介绍一下最近学习的Twitter开源的一款分布式自增ID算法sonwflake(雪花)。

snowflakeus算法是一款本地生成的（ID生成过程不依赖任何中间件，无网络通信），保证ID全局唯一，并且ID总体有序递增，性能每秒生成 300W+

考虑实际场景：举个栗子：我们有10台分布式MySql服务器，我们的系统每秒能生成10W条数据插入到这10台机器里，现在我们需要为每一条数据生成一个全局唯一的ID， 并且这些 ID 有大致的顺序。

2. snowflake算法原理

sonwflack生产的ID二进制结构表示如下：（每部分用-分开）

0 - 00000000 0000000 00000000 0000000 00000000 0 - 00000- 00000-00000000 0000

第一位未使用， 接下来的41位位毫秒级时间（41位的长度从1970-01-01 08:00:00）,然后是5位datacenterId（最大支持2^5 = 32个， 二进制表示从00000-11111， 也即是十进制0-31），和5位workerId(最大支持2^5 = 32个，原理同datacenterId),所以datacenterId*workerId最多支持部署1024个节点，最后12个是毫秒内的计数（12位的计数顺序号支持每个节点每毫秒产生2^12=4096个ID序号）。

 就可以表示：某一毫秒内的某一集群内的某一机器的第几个ID。

所有位数加在一起共64位，刚好是一个Long型(转换为字符串长度位18)。

3.snowflake算法源码(java)

package demo;

import java.util.*;
import java.util.concurrent.CountDownLatch;

/**
 * Twitter_Snowflake<br>
 * SnowFlake的结构如下(每部分用-分开):<br>
 * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000 <br>
 * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
 * 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
 * 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，年T = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
 * 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
 * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
 * 加起来刚好64位，为一个Long型。<br>
 * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
 */
public class SnowFlakeDemo {
    /** 开始时间截 (2015-01-01) */
    private final long twepoch = 1420041600000L;
    /** 机器id所占的位数 */
    private final long workerIdBits = 5L;
    /** 数据标识id所占的位数 */
    private final long datacenterIdBits = 5L;

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

    /** 支持的最大数据标识id，结果是31 */
    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);

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

    /** 机器ID向左移12位 */
    private final long workerIdShift = sequenceBits;

    /** 数据标识id向左移17位(12+5) */
    private final long datacenterIdShift = sequenceBits + workerIdBits;

    /** 时间截向左移22位(5+5+12) */
    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;

    /** 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095)    最后12位*/
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);

    /** 工作机器ID(0~31) */
    private long workerId;

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

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

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

    public SnowFlakeDemo(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
     */
    public synchronized long nextId() {
        long timestamp = timeGen();
        if(timestamp < lastTimestamp) {
            //服务器时钟被调整了,ID生成器停止服务.
            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;
    }


    protected  long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while(timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }
    protected long timeGen() {
        return System.currentTimeMillis();
    }

    //测试多线程下
    public static void testProductIdByMoreThread(int datacenterId, int workerId, int n)  throws InterruptedException {
        List<Thread> tList = new ArrayList<>();
        Set<Long> setAll = new HashSet<>();
        CountDownLatch cdLatch = new CountDownLatch(10);
        long start = System.currentTimeMillis();
        int threadNo = datacenterId;
        Map<String, SnowFlakeDemo> idFactories = new HashMap<>();
        for(int i = 0; i< 10; i++) {
            //用线程名称做map key
            idFactories.put("snowflake"+i, new SnowFlakeDemo(workerId, threadNo++));
        }
        for(int i=0;i<10;i++) {
            Thread temp = new Thread(new Runnable() {
                @Override
                public void run() {
                    Set<Long> setId = new HashSet<>();
                    SnowFlakeDemo idWorker = idFactories.get(Thread.currentThread().getName());
                    for(int j = 0; j< n; j++) {
                        setId.add(idWorker.nextId());
                    }
                    synchronized (setAll) {
                        setAll.addAll(setId);
                        System.out.println(Thread.currentThread() + "生产了" + n + "个ID，并成功加入到SetAll中");
                    }
                    cdLatch.countDown();
                }
            }, "snowflake" + i);
            tList.add(temp);
        }

        for(int j=0;j<10;j++) {
            tList.get(j).start();
        }
        cdLatch.await();

        long end1 = System.currentTimeMillis() - start;
        System.out.println("共耗时：" + end1 +",预计生成" + 10*n+"个id,实际生成数："+setAll.size());
    }

    public static void testProductId(int workerId, int datacenterId, int n) {
        SnowFlakeDemo idWorker = new SnowFlakeDemo(workerId, datacenterId);
        SnowFlakeDemo idWorker2 = new SnowFlakeDemo(workerId, datacenterId);

        Set<Long> setOne = new HashSet<>();
        Set<Long> setTwo = new HashSet<>();

        long start = System.currentTimeMillis();
        for(int i=0;i<n;i++) {
            setOne.add(idWorker.nextId());
        }
        long end1 = System.currentTimeMillis() - start;
        System.out.println("第一批预计生成"+n+"个,实际生成"+ setOne.size()+"个。共耗时" +end1);


        for (int i = 0; i < n; i++) {
            setTwo.add(idWorker2.nextId());//加入set
        }
        long end2 = System.currentTimeMillis() - start;
        System.out.println("第二批ID预计生成"+n+"个,实际生成"+ setTwo.size()+"个。共耗时" +end2);

        setOne.addAll(setTwo);
        System.out.println("合并总计生成ID个数:" + setOne.size());
    }

    public static void testPerSecondProductIdNums() {
        SnowFlakeDemo snowFlake = new SnowFlakeDemo(1,2);
        long start = System.currentTimeMillis();
        int count = 0;
        for(int i=0; System.currentTimeMillis()-start < 1000;i++,count = i) {
            //测试方法一： 此用法纯粹的生产ID，每秒生产ID个数300w+
            snowFlake.nextId();
        }
        long end = System.currentTimeMillis()-start;
        System.out.println(end);
        System.out.println(count);

    }


    public static void main(String[] args) {
/*        SnowFlakeDemo idWorker = new SnowFlakeDemo(0, 0);
        for (int i = 0; i < 1000; i++) {
            long id = idWorker.nextId();
            System.out.println(Long.toBinaryString(id));
            System.out.println(id);
        }*/
        /** case1: 测试每秒生产id个数?
         *   结论: 每秒生产id个数300w+ */
        //testPerSecondProductIdNums();
        /** case2: 单线程-测试多个生产者同时生产N个id,验证id是否有重复?
         *   结论: 验证通过,没有重复. */
        //testProductId(1,2,10000);//验证通过!
        /** case3: 多线程-测试多个生产者同时生产N个id, 全部id在全局范围内是否会重复?
         *   结论: 验证通过,没有重复. */
        try {
            testProductIdByMoreThread(1,2,100000);//单机测试此场景,性能损失至少折半!
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

4.snowflake算法推导和演算过程

说明：

演算使用的对象实例：SnowflakeIdFactory idWorker = new SnowflakeIdFactory(1, 2);

运行时数据workerId＝1，datacenterId＝2，分别表示机器实例的生产者编号，数据中心编号；

sequence＝0表示每毫秒生产ID从0开始计数递增；

以下演算基于时间戳＝1482394743339时刻进行推导。

四、Q&A
问题1：twepoch 为什么要等于1288834974657L 而不等于其他数？
答： 1288834974657 是 (Thu, 04 Nov 2010 01:42:54 GMT) 这一时刻到1970-01-01 00:00:00时刻所经过的毫秒数。41位字节作为时间戳数值的话，大约68年就会用完，假如你2010年1月1日开始开发系统，如果不减去2010年1月1日的时间戳，那么白白浪费40年的时间戳啊！所有减去twepoch 可以让系统在41位字节作为时间戳的情况下的运行时间更长。1288834974657L可能就是该项目开始成立的时间。

问题2：类似这种long maxWorkerId = -1L ^ (-1L << workerIdBits);操作是什么意思？
答： -1L ^ (-1L << n)表示占n个bit的数字的最大值是多少。举个栗子：-1L ^ (-1L << 2)等于10进制的3 ，即二进制的11表示十进制3。

注意：计算机存放数字都是存放数字的补码，正数的原码、补码、反码都一样，负数的补码是其反码加一。符号位做取反操作时不变，做逻辑与、或、非、异或操作时要参与运算。

再来个栗子：
-1L原码 : 1000 0001
-1L反码 : 1111 1110
-1L补码 : 1111 1111
-1L<<5 : 1110 0000
1111 1111 ^ 1110 0000 : 0001 1111
0001 1111是正数，所以补码、反码、原码都一样，所以0001 1111是31

问题3：((timestamp - twepoch) << timestampLeftShift) | (datacenterId << datacenterIdShift) | (workerId << workerIdShift) | sequence是什么意思？
答：我只发图不说话