查看原文
其他

Twitter的分布式雪花算法 SnowFlake 每秒自增生成26个万个可排序的ID (Java版)

搜云库 搜云库技术团队 2019-04-07

点击上面 蓝色字 “搜云库免费关注

概述

分布式系统中,有一些需要使用全局唯一ID的场景,这种时候为了防止ID冲突可以使用36位的UUID,但是UUID有一些缺点,首先他相对比较长,另外UUID一般是无序的。

有些时候我们希望能使用一种简单一些的ID,并且希望ID能够按照时间有序生成。

而twitter的SnowFlake解决了这种需求,最初Twitter把存储系统从MySQL迁移到Cassandra,因为Cassandra没有顺序ID生成机制,所以开发了这样一套全局唯一ID生成服务。

原理

Twitter的雪花算法SnowFlake,使用Java语言实现。

SnowFlake算法产生的ID是一个64位的整型,结构如下(每一部分用“-”符号分隔):

  1. 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000

1位标识部分,在java中由于long的最高位是符号位,正数是0,负数是1,一般生成的ID为正数,所以为0;

41位时间戳部分,这个是毫秒级的时间,一般实现上不会存储当前的时间戳,而是时间戳的差值(当前时间-固定的开始时间),这样可以使产生的ID从更小值开始;41位的时间戳可以使用69年,(1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69年;

10位节点部分,Twitter实现中使用前5位作为数据中心标识,后5位作为机器标识,可以部署1024个节点;

12位序列号部分,支持同一毫秒内同一个节点可以生成4096个ID;

SnowFlake算法生成的ID大致上是按照时间递增的,用在分布式系统中时,需要注意数据中心标识和机器标识必须唯一,这样就能保证每个节点生成的ID都是唯一的。或许我们不一定都需要像上面那样使用5位作为数据中心标识,5位作为机器标识,可以根据我们业务的需要,灵活分配节点部分,如:若不需要数据中心,完全可以使用全部10位作为机器标识;若数据中心不多,也可以只使用3位作为数据中心,7位作为机器标识。

snowflake生成的ID整体上按照时间自增排序,并且整个分布式系统内不会产生ID碰撞(由datacenter和workerId作区分),并且效率较高。据说:snowflake每秒能够产生26万个ID。

源码

本机实测:100万个ID 耗时5秒

  1. /**

  2. * 描述: Twitter的分布式自增ID雪花算法snowflake (Java版)

  3. * https://github.com/souyunku/SnowFlake

  4. *

  5. * @author yanpenglei

  6. * @create 2018-03-13 12:37

  7. **/

  8. public class SnowFlake {

  9.    /**

  10.     * 起始的时间戳

  11.     */

  12.    private final static long START_STMP = 1480166465631L;

  13.    /**

  14.     * 每一部分占用的位数

  15.     */

  16.    private final static long SEQUENCE_BIT = 12; //序列号占用的位数

  17.    private final static long MACHINE_BIT = 5;   //机器标识占用的位数

  18.    private final static long DATACENTER_BIT = 5;//数据中心占用的位数

  19.    /**

  20.     * 每一部分的最大值

  21.     */

  22.    private final static long MAX_DATACENTER_NUM = -1L ^ (-1L << DATACENTER_BIT);

  23.    private final static long MAX_MACHINE_NUM = -1L ^ (-1L << MACHINE_BIT);

  24.    private final static long MAX_SEQUENCE = -1L ^ (-1L << SEQUENCE_BIT);

  25.    /**

  26.     * 每一部分向左的位移

  27.     */

  28.    private final static long MACHINE_LEFT = SEQUENCE_BIT;

  29.    private final static long DATACENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;

  30.    private final static long TIMESTMP_LEFT = DATACENTER_LEFT + DATACENTER_BIT;

  31.    private long datacenterId;  //数据中心

  32.    private long machineId;     //机器标识

  33.    private long sequence = 0L; //序列号

  34.    private long lastStmp = -1L;//上一次时间戳

  35.    public SnowFlake(long datacenterId, long machineId) {

  36.        if (datacenterId > MAX_DATACENTER_NUM || datacenterId < 0) {

  37.            throw new IllegalArgumentException("datacenterId can't be greater than MAX_DATACENTER_NUM or less than 0");

  38.        }

  39.        if (machineId > MAX_MACHINE_NUM || machineId < 0) {

  40.            throw new IllegalArgumentException("machineId can't be greater than MAX_MACHINE_NUM or less than 0");

  41.        }

  42.        this.datacenterId = datacenterId;

  43.        this.machineId = machineId;

  44.    }

  45.    /**

  46.     * 产生下一个ID

  47.     *

  48.     * @return

  49.     */

  50.    public synchronized long nextId() {

  51.        long currStmp = getNewstmp();

  52.        if (currStmp < lastStmp) {

  53.            throw new RuntimeException("Clock moved backwards.  Refusing to generate id");

  54.        }

  55.        if (currStmp == lastStmp) {

  56.            //相同毫秒内,序列号自增

  57.            sequence = (sequence + 1) & MAX_SEQUENCE;

  58.            //同一毫秒的序列数已经达到最大

  59.            if (sequence == 0L) {

  60.                currStmp = getNextMill();

  61.            }

  62.        } else {

  63.            //不同毫秒内,序列号置为0

  64.            sequence = 0L;

  65.        }

  66.        lastStmp = currStmp;

  67.        return (currStmp - START_STMP) << TIMESTMP_LEFT //时间戳部分

  68.                | datacenterId << DATACENTER_LEFT       //数据中心部分

  69.                | machineId << MACHINE_LEFT             //机器标识部分

  70.                | sequence;                             //序列号部分

  71.    }

  72.    private long getNextMill() {

  73.        long mill = getNewstmp();

  74.        while (mill <= lastStmp) {

  75.            mill = getNewstmp();

  76.        }

  77.        return mill;

  78.    }

  79.    private long getNewstmp() {

  80.        return System.currentTimeMillis();

  81.    }

  82.    public static void main(String[] args) {

  83.        SnowFlake snowFlake = new SnowFlake(2, 3);

  84.        long start = System.currentTimeMillis();

  85.        for (int i = 0; i < 1000000; i++) {

  86.            System.out.println(snowFlake.nextId());

  87.        }

  88.        System.out.println(System.currentTimeMillis() - start);

  89.    }

  90. }

循环生成的ID,运行结果如下:

  1. 170916032679263329

  2. 170916032679263330

  3. 170916032679263331

  4. 170916032679263332

  5. 170916032679263333

  6. 170916032679263334

  7. 170916032679263335

  8. 170916032679263336

  9. 170916032679263337

  10. 170916032679263338

  11. 170916032679263339

  12. 170916032679263340

  13. 170916032679263341

  14. 170916032679263342

开源地址

Github: https://github.com/souyunku/SnowFlake

推荐阅读

Spring Cloud 系列教程

Spring Boot 系列教程

源码 + 教程

Github:https://github.com/souyunku/spring-boot-examples

Docker 容器

环境搭建

Contact

  • 作者:鹏磊

  • 出处:http://www.ymq.io

  • 版权归作者所有,转载请注明出处

  • Wechat:关注公众号,搜云库,专注于开发技术的研究与知识分享

    您可能也对以下帖子感兴趣

    文章有问题?点此查看未经处理的缓存