content: package com.cf.framework.utils;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.text.SimpleDateFormat;
  import java.util.Date;
  import java.util.concurrent.atomic.AtomicLong;
  
  /**
   * java edition of Twitter <b>Snowflake</b>, a network service for generating
   * unique ID numbers at high scale with some simple guarantees.
   *
   * https://github.com/twitter/snowflake
   */
  public class Snowflake {
  
      private static Logger log = LoggerFactory.getLogger(Snowflake.class);
  //    private static Logger
  	/*
  	 * bits allocations for timeStamp, datacenterId, workerId and sequence
  	 */
  
      private final long unusedBits = 1L;
      /**
       * 'time stamp' here is defined as the number of millisecond that have
       * elapsed since the {@link #epoch} given by users on {@link Snowflake}
       * instance initialization
       */
      private final long timestampBits = 41L;
      private final long datacenterIdBits = 5L;
      private final long workerIdBits = 5L;
      private final long sequenceBits = 12L;
  
      /*
       * max values of timeStamp, workerId, datacenterId and sequence
       */
      private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits); // 2^5-1
      private final long maxWorkerId = -1L ^ (-1L << workerIdBits); // 2^5-1
      private final long maxSequence = -1L ^ (-1L << sequenceBits); // 2^12-1
  
      /**
       * left shift bits of timeStamp, workerId and datacenterId
       */
      private final long timestampShift = sequenceBits + datacenterIdBits + workerIdBits;
      private final long datacenterIdShift = sequenceBits + workerIdBits;
      private final long workerIdShift = sequenceBits;
  
  	/*
  	 * object status variables
  	 */
  
      /**
       * reference material of 'time stamp' is '2016-01-01'. its value can't be
       * modified after initialization.
       */
      private final long epoch = 1451606400000L;
  
      /**
       * data center number the process running on, its value can't be modified
       * after initialization.
       * <p>
       * max: 2^5-1 range: [0,31]
       */
      private final long datacenterId;
  
      /**
       * machine or process number, its value can't be modified after
       * initialization.
       * <p>
       * max: 2^5-1 range: [0,31]
       *
       */
      private final long workerId;
  
      /**
       * the unique and incrementing sequence number scoped in only one
       * period/unit (here is ONE millisecond). its value will be increased by 1
       * in the same specified period and then reset to 0 for next period.
       * <p>
       * max: 2^12-1 range: [0,4095]
       */
      private long sequence = 0L;
  
      /** the time stamp last snowflake ID generated */
      private long lastTimestamp = -1L;
  
      /**
       * generate an unique and incrementing id
       *
       * @return id
       */
      public synchronized long nextId() {
          long currTimestamp = timestampGen();
  
          if (currTimestamp < lastTimestamp) {
              throw new IllegalStateException(
                      String.format("Clock moved backwards. Refusing to generate id for %d milliseconds",
                              lastTimestamp - currTimestamp));
          }
  
          if (currTimestamp == lastTimestamp) {
              sequence = (sequence + 1) & maxSequence;
              if (sequence == 0) { // overflow: greater than max sequence
                  currTimestamp = waitNextMillis(currTimestamp);
              }
  
          } else { // reset to 0 for next period/millisecond
              sequence = 0L;
          }
  
          // track and memo the time stamp last snowflake ID generated
          lastTimestamp = currTimestamp;
  
          return ((currTimestamp - epoch) << timestampShift) | //
                  (datacenterId << datacenterIdShift) | //
                  (workerId << workerIdShift) | // new line for nice looking
                  sequence;
      }
  
      /**
       * @param datacenterId
       *            data center number the process running on, value range: [0,31]
       * @param workerId
       *            machine or process number, value range: [0,31]
       */
      public Snowflake(long datacenterId, long workerId) {
          if (datacenterId > maxDatacenterId || datacenterId < 0) {
              throw new IllegalArgumentException(
                      String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
          }
          if (workerId > maxWorkerId || workerId < 0) {
              throw new IllegalArgumentException(
                      String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
          }
  
          this.datacenterId = datacenterId;
          this.workerId = workerId;
      }
  
      /**
       * track the amount of calling {@link #waitNextMillis(long)} method
       */
      private final AtomicLong waitCount = new AtomicLong(0);
  
      /**
       * @return the amount of calling {@link #waitNextMillis(long)} method
       */
      public long getWaitCount() {
          return waitCount.get();
      }
  
      /**
       * running loop blocking until next millisecond
       *
       * @param	currTimestamp	current time stamp
       * @return current time stamp in millisecond
       */
      protected long waitNextMillis(long currTimestamp) {
          waitCount.incrementAndGet();
          while (currTimestamp <= lastTimestamp) {
              currTimestamp = timestampGen();
          }
          return currTimestamp;
      }
  
      /**
       * get current time stamp
       *
       * @return current time stamp in millisecond
       */
      protected long timestampGen() {
          return System.currentTimeMillis();
      }
  
      /**
       * show settings of Snowflake
       */
      @Override
      public String toString() {
          return "Snowflake Settings [timestampBits=" + timestampBits + ", datacenterIdBits=" + datacenterIdBits
                  + ", workerIdBits=" + workerIdBits + ", sequenceBits=" + sequenceBits + ", epoch=" + epoch
                  + ", datacenterId=" + datacenterId + ", workerId=" + workerId + "]";
      }
  
      public long getEpoch() {
          return this.epoch;
      }
  
      /**
       * extract time stamp, datacenterId, workerId and sequence number
       * information from the given id
       *
       * @param id
       *            a snowflake id generated by this object
       * @return an array containing time stamp, datacenterId, workerId and
       *         sequence number
       */
      public long[] parseId(long id) {
          long[] arr = new long[5];
          arr[4] = ((id & diode(unusedBits, timestampBits)) >> timestampShift);
          arr[0] = arr[4] + epoch;
          arr[1] = (id & diode(unusedBits + timestampBits, datacenterIdBits)) >> datacenterIdShift;
          arr[2] = (id & diode(unusedBits + timestampBits + datacenterIdBits, workerIdBits)) >> workerIdShift;
          arr[3] = (id & diode(unusedBits + timestampBits + datacenterIdBits + workerIdBits, sequenceBits));
          return arr;
      }
  
      /**
       * extract and display time stamp, datacenterId, workerId and sequence
       * number information from the given id in humanization format
       *
       * @param id snowflake id in Long format
       * @return snowflake id in String format
       */
      public String formatId(long id) {
          long[] arr = parseId(id);
          String tmf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date(arr[0]));
          return String.format("%s, #%d, @(%d,%d)", tmf, arr[3], arr[1], arr[2]);
      }
  
      /**
       * a diode is a long value whose left and right margin are ZERO, while
       * middle bits are ONE in binary string layout. it looks like a diode in
       * shape.
       *
       * @param offset
       *            left margin position
       * @param length
       *            offset+length is right margin position
       * @return a long value
       */
      private long diode(long offset, long length) {
          int lb = (int) (64 - offset);
          int rb = (int) (64 - (offset + length));
          return (-1L << lb) ^ (-1L << rb);
      }
  
      public static void main(String[] args) {
          Snowflake idWorker = new Snowflake(1, 2);
          Snowflake idWorker2 = new Snowflake(1, 3);
          for(int i=0;i<10;i++){
              long l = idWorker.nextId();
              long l2 = idWorker2.nextId();
              System.out.println(l);
              System.out.println(l2);
          }
  
      }
  }
  
  