微服务分布式自增id实现

发表于 分类于 阅读次数： 本文字数： 1.4k 阅读时长 ≈ 5 分钟

概述

上面我们介绍了分布式自增ID算法snowflake，其中需要 工作ID和数据中心ID，在微服务中可能有很多系统，需要对每个系统都配置这两个id，导致我们需要管理工作ID和数据中心ID，使用很不方便。

假如系统可以自动去获取分配，那么可以减少配置的工作量，避免配置错误的情况。

简介

本文基于分布式自增ID算法snowflake和ZooKeeper注册中心实现自增id获取。
需要安装ZooKeeper,不会安装的同学可以参考ZooKeeper 安装

java实现

依赖ZooKeeper注册中心，需要引入ZooKeeper客户端工具，我使用的是zkclient

maven引入

1
2
3
4
5
<dependency>
  <groupId>com.101tec</groupId>
  <artifactId>zkclient</artifactId>
  <version>0.10</version>
</dependency>

创建Snowflake算法生成唯一id实现类

id自动生成实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
package com.fallsea.id.snowflake;

/**
 * @Description: Snowflake算法生成唯一id
 * @Copyright: 2017 www.fallsea.com Inc. All rights reserved.
 * @author: fallsea
 * @version 1.0
 * @date: 2017年10月22日 下午8:31:32
 */
public class SnowflakeIdWorker
{
    /** 开始时间截 (2015-01-01) */
    private final long twepoch = 1420041600000L;

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

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

    /** 支持的最大机器id，结果是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) */
    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;


    /**
     * @Description: 构造函数
     * @author: fallsea
     * @date: 2017年10月22日 下午8:31:46
     * @param workerId 工作ID (0~31)
     * @param datacenterId 数据中心ID (0~31)
     */
    public SnowflakeIdWorker(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;
    }

    /**
     * @Description: 获得下一个ID (该方法是线程安全的)
     * @author: fallsea
     * @date: 2017年10月22日 下午8:32:03
     * @return
     */
    public synchronized long nextId() {
        long timestamp = timeGen();

        //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
        if (timestamp < lastTimestamp) {
            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;
    }

    /**
     * @Description: 阻塞到下一个毫秒，直到获得新的时间戳
     * @author: fallsea
     * @date: 2017年10月22日 下午8:32:19
     * @param lastTimestamp 上次生成ID的时间截
     * @return 当前时间戳
     */
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    /**
     * @Description: 返回以毫秒为单位的当前时间
     * @author: fallsea
     * @date: 2017年10月22日 下午8:32:36
     * @return 当前时间(毫秒)
     */
    protected long timeGen() {
        return System.currentTimeMillis();
    }

}

创建id生成工具类

通过zkclient 连接ZooKeeper注册中心，注册中心维护snowflake的工作id(0-1023)，达到0配置的分布式id自动生成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package com.fallsea.id.snowflake;

import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

import org.I0Itec.zkclient.ZkClient;

/**
 * @Description: id工具类
 * @Copyright: 2017 www.fallsea.com Inc. All rights reserved.
 * @author: fallsea
 * @version 1.0
 * @date: 2017年12月11日 上午10:20:35
 */
public class IdUtil {

	/**
	 * zk客户端
	 */
	private static volatile ZkClient zkClient;

	/**
	 * zk根节点
	 */
	public static final String ROOT_PATH = "/fallsea";


	/**
     * 分布式id节点
     */
    public static final String SNOWFLAKE_ID_PATH = ROOT_PATH + "/SnowflakeId";

    /**
     * 可用的工作id集合(0-1023)
     */
	private static volatile Set<Long> WORKER_ID_SET;

    private static volatile SnowflakeIdWorker idWorker = null;

    /**
     * 当前工作id
     */
    private static volatile long WORKER_ID ;


    static
    {
    	//实例化zk客户端
    	zkClient = new ZkClient("127.0.0.1:2181",3000,5000);


        WORKER_ID_SET = new HashSet<Long>();
        for (long i = 0; i < 1024; i++)
        {
            WORKER_ID_SET.add(i);
        }

        //判断节点是否存在，不存在则创建
        if(!zkClient.exists(SNOWFLAKE_ID_PATH))
        {
            // 创建一个目录节点
        	zkClient.createPersistent(SNOWFLAKE_ID_PATH);
        }

        WORKER_ID = getWorkerId();

        //通过workerId 计算工作ID 和数据中心
        long workerId = WORKER_ID/32;//工作id
        long datacenterId = WORKER_ID%32;//数据中心

        idWorker = new SnowflakeIdWorker(workerId, datacenterId);

    }

    /**
     * @Description: 获取id
     * @author: fallsea
     * @date: 2017年10月22日 下午8:43:21
     * @return
     */
    public static long getId()
    {
        return idWorker.nextId();
    }


    /**
     * @Description: 获取workerId(0-1023的值)
     * @author: fallsea
     * @date: 2017年10月22日 下午8:43:52
     * @return
     */
    private static Long getWorkerId()
    {

        //查询子节点列表
        List<String> list = zkClient.getChildren(SNOWFLAKE_ID_PATH);
        if(null != list && !list.isEmpty())
        {
            if(list.size()==1024)
            {
                return -1L;
            }
            for (String str : list)
            {
                WORKER_ID_SET.remove(Long.valueOf(str));
            }
        }

        long workerId=-1L;

        if(!WORKER_ID_SET.isEmpty())
        {
            Long[] workerIds=WORKER_ID_SET.toArray(new Long[]{});
            workerId=workerIds[new Random().nextInt(WORKER_ID_SET.size())];

            //判断是否存在，如果不存在，则创建
            if(!zkClient.exists(SNOWFLAKE_ID_PATH+"/"+workerId))
            {
            	zkClient.createEphemeral(SNOWFLAKE_ID_PATH+"/"+workerId);
            }
            else
            {
                return getWorkerId();
            }
        }
        return workerId;
    }

}

测试类

运行测试类，查看id生成结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package com.fallsea.id.snowflake;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * @Description: 测试类
 * @Copyright: 2017 www.fallsea.com Inc. All rights reserved.
 * @author: fallsea
 * @version 1.0
 * @date: 2017年12月11日 下午1:35:17
 */
public class AppTest
    extends TestCase
{
    /**
     * Create the test case
     *
     * @param testName name of the test case
     */
    public AppTest( String testName )
    {
        super( testName );
    }

    /**
     * @return the suite of tests being tested
     */
    public static Test suite()
    {
        return new TestSuite( AppTest.class );
    }

    /**
     * Rigourous Test :-)
     */
    public void testApp()
    {

    	long startTime = System.currentTimeMillis();

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

    		long id = IdUtil.getId();
    		System.out.println(endTime - startTime );
		}

    	long endTime = System.currentTimeMillis();

    	System.out.println(endTime - startTime );


        assertTrue( true );
    }
}

源码下载

github下载
码云下载