45、分庫分表之後全域性id咋生成？
1、面試題
分庫分表之後，id主鍵如何處理？
2、面試官心裡分析
其實這是分庫分表之後你必然要面對的一個問題，就是id咋生成？因為要是分成多個表之後，每個表都是從1開始累加，那肯定不對啊，需要一個全域性唯一的id來支援。所以這都是你實際生產環境中必須考慮的問題。
3、面試題剖析
（1）資料庫自增id
這個就是說你的系統裡每次得到一個id，都是往一個庫的一個表裡插入一條沒什麼業務含義的資料，然後獲取一個數據庫自增的一個id。拿到這個id之後再往對應的分庫分表裡去寫入。
這個方案的好處就是方便簡單，誰都會用；缺點就是單庫生成自增id，要是高併發的話，就會有瓶頸的；如果你硬是要改進一下，那麼就專門開一個服務出來，這個服務每次就拿到當前id最大值，然後自己遞增幾個id，一次性返回一批id，然後再把當前最大id值修改成遞增幾個id之後的一個值；但是無論怎麼說都是基於單個數據庫。
適合的場景：你分庫分表就倆原因，要不就是單庫併發太高，要不就是單庫資料量太大；除非是你併發不高，但是資料量太大導致的分庫分表擴容，你可以用這個方案，因為可能每秒最高併發最多就幾百，那麼就走單獨的一個庫和表生成自增主鍵即可。
併發很低，幾百/s，但是資料量大，幾十億的資料，所以需要靠分庫分表來存放海量的資料
（2）uuid
好處就是本地生成，不要基於資料庫來了；不好之處就是，uuid太長了，作為主鍵效能太差了，不適合用於主鍵。
適合的場景：如果你是要隨機生成個什麼檔名了，編號之類的，你可以用uuid，但是作為主鍵是不能用uuid的。
UUID.randomUUID().toString().replace(“-”, “”) -> sfsdf23423rr234sfdaf
分庫分表的id主鍵問題.png
（3）獲取系統當前時間
這個就是獲取當前時間即可，但是問題是，併發很高的時候，比如一秒併發幾千，會有重複的情況，這個是肯定不合適的。基本就不用考慮了。
適合的場景：一般如果用這個方案，是將當前時間跟很多其他的業務欄位拼接起來，作為一個id，如果業務上你覺得可以接受，那麼也是可以的。你可以將別的業務欄位值跟當前時間拼接起來，組成一個全域性唯一的編號，訂單編號，時間戳 + 使用者id + 業務含義編碼
（4）snowflake演算法
snowflake演算法.png
twitter開源的分散式id生成演算法，就是把一個64位的long型的id，1個bit是不用的，用其中的41 bit作為毫秒數，用10 bit作為工作機器id，12 bit作為序列號
1 bit：不用，為啥呢？因為二進位制裡第一個bit為如果是1，那麼都是負數，但是我們生成的id都是正數，所以第一個bit統一都是0
41 bit：表示的是時間戳，單位是毫秒。41 bit可以表示的數字多達2^41 - 1，也就是可以標識2 ^ 41 - 1個毫秒值，換算成年就是表示69年的時間。
10 bit：記錄工作機器id，代表的是這個服務最多可以部署在2^10臺機器上哪，也就是1024臺機器。但是10 bit裡5個bit代表機房id，5個bit代表機器id。意思就是最多代表2 ^ 5個機房（32個機房），每個機房裡可以代表2 ^ 5個機器（32臺機器）。
12 bit：這個是用來記錄同一個毫秒內產生的不同id，12 bit可以代表的最大正整數是2 ^ 12 - 1 = 4096，也就是說可以用這個12bit代表的數字來區分同一個毫秒內的4096個不同的id
64位的long型的id，64位的long -> 二進位制
0 | 0001100 10100010 10111110 10001001 01011100 00 | 10001 | 1 1001 | 0000 00000000
2018-01-01 10:00:00 -> 做了一些計算，再換算成一個二進位制，41bit來放 -> 0001100 10100010 10111110 10001001 01011100 00
機房id，17 -> 換算成一個二進位制 -> 10001
機器id，25 -> 換算成一個二進位制 -> 11001
snowflake演算法服務，會判斷一下，當前這個請求是否是，機房17的機器25，在2175/11/7 12:12:14時間點發送過來的第一個請求，如果是第一個請求
假設，在2175/11/7 12:12:14時間裡，機房17的機器25，傳送了第二條訊息，snowflake演算法服務，會發現說機房17的機器25，在2175/11/7 12:12:14時間裡，在這一毫秒，之前已經生成過一個id了，此時如果你同一個機房，同一個機器，在同一個毫秒內，再次要求生成一個id，此時我只能把加1
0 | 0001100 10100010 10111110 10001001 01011100 00 | 10001 | 1 1001 | 0000 00000001
比如我們來觀察上面的那個，就是一個典型的二進位制的64位的id，換算成10進位制就是910499571847892992。
public class IdWorker{
private long workerId;
private long datacenterId;
private long sequence;
public IdWorker(long workerId, long datacenterId, long sequence){
// sanity check for workerId
// 這兒不就檢查了一下，要求就是你傳遞進來的機房id和機器id不能超過32，不能小於0
if (workerId > maxWorkerId || workerId < 0) {
throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0",maxWorkerId));
}
if (datacenterId > maxDatacenterId || datacenterId < 0) {
throw new IllegalArgumentException(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;
}
private long twepoch = 1288834974657L;
private long workerIdBits = 5L;
private long datacenterIdBits = 5L;
private long maxWorkerId = -1L ^ (-1L << workerIdBits); // 這個是二進位制運算，就是5 bit最多隻能有31個數字，也就是說機器id最多隻能是32以內
private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits); // 這個是一個意思，就是5 bit最多隻能有31個數字，機房id最多隻能是32以內
private long sequenceBits = 12L;
private long workerIdShift = sequenceBits;
private long datacenterIdShift = sequenceBits + workerIdBits;
private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
private long sequenceMask = -1L ^ (-1L << sequenceBits);
private long lastTimestamp = -1L;
public long getWorkerId(){
return workerId;
}
public long getDatacenterId(){
return datacenterId;
}
public long getTimestamp(){
return System.currentTimeMillis();
}
public synchronized long nextId() {
// 這兒就是獲取當前時間戳，單位是毫秒
long timestamp = timeGen();
if (timestamp < lastTimestamp) {
System.err.printf("clock is moving backwards. Rejecting requests until %d.", lastTimestamp);
throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds",
lastTimestamp - timestamp));
}
// 0
// 在同一個毫秒內，又傳送了一個請求生成一個id，0 -> 1
if (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;
}
0 | 0001100 10100010 10111110 10001001 01011100 00 | 10001 | 1 1001 | 0000 00000000
private long tilNextMillis(long lastTimestamp) {
long timestamp = timeGen();
while (timestamp <= lastTimestamp) {
timestamp = timeGen();
}
return timestamp;
}
private long timeGen(){
return System.currentTimeMillis();
}
//---------------測試---------------
public static void main(String[] args) {
IdWorker worker = new IdWorker(1,1,1);
for (int i = 0; i < 30; i++) {
System.out.println(worker.nextId());
}
}
}
怎麼說呢，大概這個意思吧，就是說41 bit，就是當前毫秒單位的一個時間戳，就這意思；然後5 bit是你傳遞進來的一個機房id（但是最大隻能是32以內），5 bit是你傳遞進來的機器id（但是最大隻能是32以內），剩下的那個10 bit序列號，就是如果跟你上次生成id的時間還在一個毫秒內，那麼會把順序給你累加，最多在4096個序號以內。
所以你自己利用這個工具類，自己搞一個服務，然後對每個機房的每個機器都初始化這麼一個東西，剛開始這個機房的這個機器的序號就是0。然後每次接收到一個請求，說這個機房的這個機器要生成一個id，你就找到對應的Worker，生成。
他這個演算法生成的時候，會把當前毫秒放到41 bit中，然後5 bit是機房id，5 bit是機器id，接著就是判斷上一次生成id的時間如果跟這次不一樣，序號就自動從0開始；要是上次的時間跟現在還是在一個毫秒內，他就把seq累加1，就是自動生成一個毫秒的不同的序號。
這個演算法那，可以確保說每個機房每個機器每一毫秒，最多生成4096個不重複的id。
利用這個snowflake演算法，你可以開發自己公司的服務，甚至對於機房id和機器id，反正給你預留了5 bit + 5 bit，你換成別的有業務含義的東西也可以的。
這個snowflake演算法相對來說還是比較靠譜的，所以你要真是搞分散式id生成，如果是高併發啥的，那麼用這個應該效能比較好，一般每秒幾萬併發的場景，也足夠你用了。