algoritmo de número de ordem geração neve

/ ** 
 * Twitter_Snowflake <br> 
 * Snowflake seguinte estrutura (com cada seção - intervalo): <br> 
 * 0 - 0 0000000000 0000000000 0000000000 0000000000 - 0000000000-000000000000 <br> 
 * identificador de bit 1, uma vez que os tipos básicos de comprimento. é assinado em Java, o bit mais significativo é um bit de sinal, 0 é um número positivo, o número negativo é 1, então o ID é geralmente um número positivo, o bit mais significativo é 0 <br> 
 * 41 tempo de corte (milissegundos), observou 41 o tempo não é um tempo de corte da corrente de armazenamento de corte do tempo, mas a diferença entre o tempo de armazenamento do ponto de corte (cut-off tempo corrente - o tempo de início de corte) 
 * o valor obtido), onde o tempo de início de uma truncado, geralmente começamos com gerador de id tempo especificado pelo nosso programa (programa seguinte IdWorker startTime classe atributo abaixo). De corte do tempo 41, 69 podem ser utilizados em, em = t (1L << 41 é) / (1000L * 60 * 60 * 24 * 365) = 69 <br> 
 * máquina de bit de dados de 10 bits, pode ser implantado em 1024 nodos, e incluindo 5 datacenterId <br> 5 workerId 
 * 12 contagem de sequência dentro de milissegundos, a contagem do número de sequência 12 de cada nó de suporte por milissegundo (a mesma máquina, o mesmo corte vez) para produzir o número de identificação 4096 <br > 
 * somam apenas 64 para um tipo Long. <br> 
 * Vantagem do floco é que o incremento global em ordem de tempo, e não geram colisões ID (como distinguida da ID e ID de máquina centro de dados) em todo o sistema distribuído, e alta eficiência, testado, podem ser geradas por segundo floco de neve cerca de 260.000 ID. 
 * / 
Público classe SnowflakeIdWorker { 

    // ============================== Campos ============== ============================= 
    / ** tempo de início de corte (2015/01/01) * / 
    privado  final  longo twepoch = 1420041600000L ; 

    / ** share com quatro dígitos do ID de máquina * / 
    privados  finais  longas workerIdBits = 5L ; 

    / ** dados para identificar o número de bits ocupados por id * / 
    privados  finais  longas datacenterIdBits = 5L ; 

    / ** o máximo suportado ID de máquina, resultados é 31 (o algoritmo de deslocamento pode calcular rapidamente o número máximo de binário número decimal pode representar vários) * / 
    privado  final  longo maxWorkerId -1L = ^ (<< -1LworkerIdBits); 

    / ** O máximo ID de identificação de dados, resultam 31 é * / 
    privada  final  longo maxDatacenterId -1L = ^ (-1L << datacenterIdBits); 

    / ** sequência representando o ID de mediana * / 
    privada  final  longo = 12L sequenceBits ; 

    / ** ID da máquina 12 para a esquerda * / 
    privado  final  longo workerIdShift = sequenceBits; 

    / ** dados de identificação id para o 17 para a esquerda (+ 12 é 5.) * / 
    privado  final  longo datacenterIdShift + = sequenceBits workerIdBits; 

    / * hora de cortar à esquerda 22 (. 5 + + 12 é. 5) * / 
    privado  final  longoworkerIdBits + + = sequenceBits timestampLeftShift datacenterIdBits; 

    / ** gerando uma sequência de máscara, aqui 4095 (0b111111111111 = 0xFFF = 4095) * / 
    Privado  final  longo sequenceMask -1L = ^ (-1L << sequenceBits); 

    / ** máquina de trabalho ID (~ 31 é 0) * / 
    privado  longo workerId; 

    / ** ID de centro de dados (~ 31 é 0) * / 
    privado  longo datacenterId; 

    / ** milissegundos seqüência (0 ~ 4095) * / 
    privado  longa seqüência = 0D ; 

    / * * última gerado ID tempo seccional * / 
    privado  longo LastTimestamp = -1L ; 

    //============================== Construtores =================== ================== 
    / ** 
     *构造函数
     * @ param workerId工作ID (0 ~ 31) 
     * @ param datacenterId数据中心ID (0 ~ 31)
      * / 
    público SnowflakeIdWorker ( longa workerId, longa datacenterId) {
         se (workerId> maxWorkerId || workerId <0 ) {
             lançar  novos IllegalArgumentException (String.format ( "trabalhador Id não pode ser maior que% d ou inferior a 0" , maxWorkerId)); 
        } 
        Se (datacenterId> maxDatacenterId || datacenterId <0 ) {
            o lance  novo novo um IllegalArgumentException (String.format ( "não pode ser Datacenter Id dentro de Greater% ou menos dentro de D 0" , maxDatacenterId)); 
        } 
        a este .workerId = workerId;
         a este .datacenterId = datacenterId; 
    } 

    // ================ ========================= Métodos ======================== ================== 
    / ** 
     * obter o próximo ID (que é thread-safe) 
     * @return SnowflakeId
      * / 
    público  a sincronizado  longo NextID () {
         longo timestamp = TIMEGEN (); 

        // se a hora atual é menor do que o timestamp do ID de última geração, indicando o tempo de recuo relógio do sistema deve ser jogado sobre este 
        caso(Timestamp < LastTimestamp) {
             throw  new new um RuntimeException ( 
                    String.format ( "Clock movida para trás ID por se recusar a gerar milissegundos% d.", LastTimestamp - timestamp)); 
        } 

        // se for gerado, ao mesmo tempo, a seqüência é executada dentro de milissegundos 
        IF (LastTimestamp == timestamp) { 
            sequência = (+ sequência 1.) & sequenceMask;
             // milissegundo transbordamento sequcia 
            SE (sequência == 0 ) {
                 // bloqueando o próximo milissegundo, obter uma nova data e hora 
                timestamp = tilNextMillis (LastTimestamp ); 
            } 
        } 
        //Timestamp muda, os milissegundos seqüência de reset 
        a outra { 
            Seqüência = 0D ; 
        } 

        // última vez geração ID corte 
        LastTimestamp = timestamp; 

        // mudança para a luta e ORed juntos formam um ID de 64 bits 
        retorno ((timestamp - twepoch) << timestampLeftShift) //
                 | (datacenterId << datacenterIdShift) //
                 | (workerId << workerIdShift) //
                 | Sequence; 
    } 

    / ** 
     * obstrução para o próximo milissegundo, até que um novo timestamp 
     * @ param LastTimestamp tempo último corte geração ID 
     * @return o timestamp atual
      * / 
    protegida Longo tilNextMillis ( longa LastTimestamp) {
         longa timestamp = TIMEGEN ();
         o tempo (timestamp <= LastTimestamp) { 
            timestamp = TIMEGEN (); 
        } 
        return timestamp; 
    } 

    / ** 
     * Retorna a hora atual em milissegundos 
     * @return tempo atual (ms)
      * / 
    protegida  longa TIMEGEN () {
         return System.currentTimeMillis (); 
    } 

    // ============================= ============================================= o teste = 
    / ** teste * /
    público  estático  vazio principais (String [] args) { 
        SnowflakeIdWorker idWorker = new SnowflakeIdWorker (0, 0 );
        para ( int i = 0; i <1,000; i ++ ) {
             longo ID = idWorker.nextId (); 
            System.out.printlnl (Long.toBinaryString (id)); 
            System.out.printlnl (id); 
        } 
    } 
}