分库分布的几件小事（四）分库分表的id主键生成

publicclassIdWorker{
privatelongworkerId;
privatelongdatacenterId;
privatelongsequence;
publicIdWorker(longworkerId, longdatacenterId, longsequence){
// sanity check for workerId// 这儿不就检查了一下，要求就是你传递进来的机房id和机器id不能超过32，不能小于0if (workerId>maxWorkerId||workerId<0) {
thrownewIllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0",maxWorkerId));
        }
if (datacenterId>maxDatacenterId||datacenterId<0) {
thrownewIllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0",maxDatacenterId));
        }
System.out.printf("worker starting. timestamp left shift %d, datacenter id bits %d, worker id bits %d, sequence bits %d, workerid %d",
timestampLeftShift, datacenterIdBits, workerIdBits, sequenceBits, workerId);
this.workerId=workerId;
this.datacenterId=datacenterId;
this.sequence=sequence;
    }
privatelongtwepoch=1288834974657L;
privatelongworkerIdBits=5L;
privatelongdatacenterIdBits=5L;
privatelongmaxWorkerId=-1L^ (-1L<<workerIdBits); // 这个是二进制运算，就是5 bit最多只能有31个数字，也就是说机器id最多只能是32以内privatelongmaxDatacenterId=-1L^ (-1L<<datacenterIdBits); // 这个是一个意思，就是5 bit最多只能有31个数字，机房id最多只能是32以内privatelongsequenceBits=12L;
privatelongworkerIdShift=sequenceBits;
privatelongdatacenterIdShift=sequenceBits+workerIdBits;
privatelongtimestampLeftShift=sequenceBits+workerIdBits+datacenterIdBits;
privatelongsequenceMask=-1L^ (-1L<<sequenceBits);
privatelonglastTimestamp=-1L;
publiclonggetWorkerId(){
returnworkerId;
    }
publiclonggetDatacenterId(){
returndatacenterId;
    }
publiclonggetTimestamp(){
returnSystem.currentTimeMillis();
    }
publicsynchronizedlongnextId() {
// 这儿就是获取当前时间戳，单位是毫秒longtimestamp=timeGen();
if (timestamp<lastTimestamp) {
System.err.printf("clock is moving backwards.  Rejecting requests until %d.", lastTimestamp);
thrownewRuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds",
lastTimestamp-timestamp));
        }
// 0// 在同一个毫秒内，又发送了一个请求生成一个id，0 -> 1if (lastTimestamp==timestamp) {
sequence= (sequence+1) &sequenceMask; // 这个意思是说一个毫秒内最多只能有4096个数字，无论你传递多少进来，这个位运算保证始终就是在4096这个范围内，避免你自己传递个sequence超过了4096这个范围if (sequence==0) {
timestamp=tilNextMillis(lastTimestamp);
            }
        } else {
sequence=0;
        }
// 这儿记录一下最近一次生成id的时间戳，单位是毫秒lastTimestamp=timestamp;
// 这儿就是将时间戳左移，放到41 bit那儿；将机房id左移放到5 bit那儿；将机器id左移放到5 bit那儿；将序号放最后10 bit；最后拼接起来成一个64 bit的二进制数字，转换成10进制就是个long型return ((timestamp-twepoch) <<timestampLeftShift) |                (datacenterId<<datacenterIdShift) |                (workerId<<workerIdShift) |sequence;
    }
privatelongtilNextMillis(longlastTimestamp) {
longtimestamp=timeGen();
while (timestamp<=lastTimestamp) {
timestamp=timeGen();
        }
returntimestamp;
    }
privatelongtimeGen(){
returnSystem.currentTimeMillis();
    }
//---------------测试---------------publicstaticvoidmain(String[] args) {
IdWorkerworker=newIdWorker(1,1,1);
for (inti=0; i<30; i++) {
System.out.println(worker.nextId());
        }
    }
}