雪花算法：分布式唯一ID生成利器

public class SnowFlake {

 /**
  * 起始的时间戳（可设置当前时间之前的邻近时间）
  */
 private final static long START_STAMP = 1480166465631L;

 /**
  * 序列号占用的位数
  */
 private final static long SEQUENCE_BIT = 12;
 /**
  * 机器标识占用的位数
  */
 private final static long MACHINE_BIT = 5;
 /**
  * 数据中心占用的位数
  */
 private final static long DATA_CENTER_BIT = 5;

 /**
  * 每一部分的最大值
  */
 private final static long MAX_DATA_CENTER_NUM = ~(-1L << DATA_CENTER_BIT);
 private final static long MAX_MACHINE_NUM = ~(-1L << MACHINE_BIT);
 private final static long MAX_SEQUENCE = ~(-1L << SEQUENCE_BIT);

 /**
  * 每一部分向左的位移
  */
 private final static long MACHINE_LEFT = SEQUENCE_BIT;
 private final static long DATA_CENTER_LEFT = SEQUENCE_BIT + MACHINE_BIT;
 private final static long TIMESTAMP_LEFT = DATA_CENTER_LEFT + DATA_CENTER_BIT;

 /**
  * 数据中心ID(0~31)
  */
 private final long dataCenterId;
 /**
  * 工作机器ID(0~31)
  */
 private final long machineId;
 /**
  * 毫秒内序列(0~4095)
  */
 private long sequence = 0L;
 /**
  * 上次生成ID的时间截
  */
 private long lastStamp = -1L;

 public SnowFlake(long dataCenterId, long machineId) {
  if (dataCenterId > MAX_DATA_CENTER_NUM || dataCenterId < 0) {
   throw new IllegalArgumentException("dataCenterId can't be greater than MAX_DATA_CENTER_NUM or less than " +
     "0");
  }
  if (machineId > MAX_MACHINE_NUM || machineId < 0) {
   throw new IllegalArgumentException("machineId can't be greater than MAX_MACHINE_NUM or less than 0");
  }
  this.dataCenterId = dataCenterId;
  this.machineId = machineId;
 }

 /**
  * 产生下一个ID
  */
 public synchronized long nextId() {
  long currStamp = getNewStamp();
  if (currStamp < lastStamp) {
   throw new RuntimeException("Clock moved backwards.  Refusing to generate id");
  }

  if (currStamp == lastStamp) {
   //相同毫秒内，序列号自增
   sequence = (sequence + 1) & MAX_SEQUENCE;
   //同一毫秒的序列数已经达到最大
   if (sequence == 0L) {
    //阻塞到下一个毫秒,获得新的时间戳
    currStamp = getNextMill();
   }
  } else {
   //不同毫秒内，序列号置为0
   sequence = 0L;
  }

  lastStamp = currStamp;

  // 移位并通过或运算拼到一起组成64位的ID
  return (currStamp - START_STAMP) << TIMESTAMP_LEFT //时间戳部分
    | dataCenterId << DATA_CENTER_LEFT       //数据中心部分
    | machineId << MACHINE_LEFT             //机器标识部分
    | sequence;                             //序列号部分
 }

 private long getNextMill() {
  long mill = getNewStamp();
  while (mill <= lastStamp) {
   mill = getNewStamp();
  }
  return mill;
 }

 private long getNewStamp() {
  return System.currentTimeMillis();
 }

 public static void main(String[] args) {
  SnowFlake snowFlake = new SnowFlake(11, 11);

  long start = System.currentTimeMillis();
  for (int i = 0; i < 10; i++) {
   System.out.println(snowFlake.nextId());
  }

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

public static void main(String[] args) {
   //41位二进制最小值
   String minTimeStampStr = "00000000000000000000000000000000000000000";
   //41位二进制最大值
   String maxTimeStampStr = "11111111111111111111111111111111111111111";
   //转10进制
   long minTimeStamp = new BigInteger(minTimeStampStr, 2).longValue();
   long maxTimeStamp = new BigInteger(maxTimeStampStr, 2).longValue();
   //一年总共多少毫秒
   long oneYearMills = 1L * 1000 * 60 * 60 * 24 * 365;
   //算出最大可以多少年
   System.out.println((maxTimeStamp - minTimeStamp) / oneYearMills);
}