public final class SnowflakeShardingKeyGenerator implements ShardingKeyGenerator {
    
    public static final long EPOCH;
    
    private static final long SEQUENCE_BITS = 12L;
    
    private static final long WORKER_ID_BITS = 10L;
    //mask的作用就是將sequence所代表的最后12位全部置為1影涉，方便后面做位于運(yùn)算
    private static final long SEQUENCE_MASK = (1 << SEQUENCE_BITS) - 1;
    
    private static final long WORKER_ID_LEFT_SHIFT_BITS = SEQUENCE_BITS;
    
    private static final long TIMESTAMP_LEFT_SHIFT_BITS = WORKER_ID_LEFT_SHIFT_BITS + WORKER_ID_BITS;
    
    private static final long WORKER_ID_MAX_VALUE = 1L << WORKER_ID_BITS;
    
    private static final long WORKER_ID = 0;
    
    private static final int MAX_TOLERATE_TIME_DIFFERENCE_MILLISECONDS = 10;
    
    @Setter
    private static TimeService timeService = new TimeService();
    
    @Getter
    @Setter
    private Properties properties = new Properties();
    
    private byte sequenceOffset;
    /**
     * 毫秒內(nèi)自增序列(0~4095) 既最后的12個(gè)bit位莱褒，2^12-1
     */
    private long sequence;
    
    private long lastMilliseconds;
    
    static {
        Calendar calendar = Calendar.getInstance();
        calendar.set(2016, Calendar.NOVEMBER, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        EPOCH = calendar.getTimeInMillis();
    }
    
    @Override
    public String getType() {
        return "SNOWFLAKE";
    }
    
    @Override
    public synchronized Comparable<?> generateKey() {

        long currentMilliseconds = timeService.getCurrentMillis();
        //處理時(shí)間回溯問題
        if (waitTolerateTimeDifferenceIfNeed(currentMilliseconds)) {
            currentMilliseconds = timeService.getCurrentMillis();
        }
        //如果是在同一毫秒中調(diào)用此方法提佣，
        if (lastMilliseconds == currentMilliseconds) {
            //這里是一個(gè)位運(yùn)算肚吏，因?yàn)閟equence最多只允許占用最低的12位方妖，一旦+1的步驟達(dá)到4096，
            //達(dá)到了13位须喂，既2^13,通過和SEQUENCE_MASK做位與運(yùn)算，重置為0
            if (0L == (sequence = (sequence + 1) & SEQUENCE_MASK)) {
                //一旦重置為0后趁蕊，說明這一毫秒能生成的key已達(dá)到上限坞生，則進(jìn)入循環(huán)等待下一個(gè)毫秒。
                // 因?yàn)閮H僅是一個(gè)毫秒的差距掷伙，所以沒有使用sleep是己，直接while循環(huán)節(jié)省cpu調(diào)用
                currentMilliseconds = waitUntilNextTime(currentMilliseconds);
            }
        } else {
            //如果不是在同一毫秒中并發(fā)調(diào)用此方法
            vibrateSequenceOffset();
            sequence = sequenceOffset;
        }
        lastMilliseconds = currentMilliseconds;
        /**
         * (currentMilliseconds - EPOCH) << TIMESTAMP_LEFT_SHIFT_BITS) 時(shí)間毫秒數(shù)往右移動(dòng)22位，避開workId和sequence任柜，放到高位的41位
         * (getWorkerId() << WORKER_ID_LEFT_SHIFT_BITS) 將workId左移到隨后的10位上
         * 最后是sequence占據(jù)低位的12位
         *
         * 最后用或運(yùn)算將三個(gè)部分組合到一個(gè)long中,返回最終的結(jié)果
         */
        return ((currentMilliseconds - EPOCH) << TIMESTAMP_LEFT_SHIFT_BITS) | (getWorkerId() << WORKER_ID_LEFT_SHIFT_BITS) | sequence;
    }

    /**
     * 如果當(dāng)前時(shí)間沒有回溯過卒废，直接返回false，不等待
     * 如果當(dāng)前時(shí)間回溯過宙地，如果在允許的時(shí)間范圍內(nèi)摔认，就sleep，返回true宅粥，表示等待過
     *                  如果超過了允許的時(shí)間范圍参袱，直接拋出異常。
     * @param currentMilliseconds
     * @return
     */
    @SneakyThrows
    private boolean waitTolerateTimeDifferenceIfNeed(final long currentMilliseconds) {
        if (lastMilliseconds <= currentMilliseconds) {
            return false;
        }
        //回溯的時(shí)間毫秒數(shù)
        long timeDifferenceMilliseconds = lastMilliseconds - currentMilliseconds;

        Preconditions.checkState(timeDifferenceMilliseconds < getMaxTolerateTimeDifferenceMilliseconds(), 
                "Clock is moving backwards, last time is %d milliseconds, current time is %d milliseconds", lastMilliseconds, currentMilliseconds);
        Thread.sleep(timeDifferenceMilliseconds);
        return true;
    }
    
    private long getWorkerId() {
        long result = Long.valueOf(properties.getProperty("worker.id", String.valueOf(WORKER_ID)));
        Preconditions.checkArgument(result >= 0L && result < WORKER_ID_MAX_VALUE);
        return result;
    }
    
    private int getMaxTolerateTimeDifferenceMilliseconds() {
        return Integer.valueOf(properties.getProperty("max.tolerate.time.difference.milliseconds", String.valueOf(MAX_TOLERATE_TIME_DIFFERENCE_MILLISECONDS)));
    }
    
    private long waitUntilNextTime(final long lastTime) {
        long result = timeService.getCurrentMillis();
        while (result <= lastTime) {
            result = timeService.getCurrentMillis();
        }
        return result;
    }

    /**
     * byte的初始值0000 0000
     * ~取反后就是-1秽梅，二進(jìn)制1111 1111
     * 和1做位于運(yùn)算,0000 0001抹蚀，可以發(fā)現(xiàn)，甭管你是多少企垦，最后都只會(huì)留下最低位环壤，1或者0
     * sequenceOffset最開始是0，結(jié)果就是1
     * sequenceOffset變成1后钞诡，一通操作后結(jié)果就是0
     *
     * 所以這個(gè)sequenceOffset每次調(diào)用循環(huán)變成0郑现，1.
     * 這個(gè)原理是為了讓在分布式環(huán)境中低QPS的時(shí)候湃崩，末尾不總是0，就不會(huì)全是偶數(shù)懂酱。造成切片堆積
     * http://www.reibang.com/p/2428ac820055
     */
    private void vibrateSequenceOffset() {
        sequenceOffset = (byte) (~sequenceOffset & 1);
    }
}