分庫分表後每個表還都從1開始累加肯定有問題，需要全局唯一id的生成器，下面詳解各種方案優缺點。
1 資料庫自增id
提供一個專門用于生成主鍵的庫，這樣服務每次接收請求都
- 先往單點庫的某表裡插入一條沒啥業務含義的資料
- 然後擷取一個資料庫自增id
- 取得id後，再寫入對應的分庫分表
優點
簡單，是人都會
缺點
因為是單庫生成自增id，是以若是高并發場景，就會有性能瓶頸。
若硬是要改進，那就專門開個服務：
- 該服務每次就拿到目前id最大值
- 然後自己遞增幾個id，一次性傳回一批id
- 然後再把目前最大id值修改成遞增幾個id之後的一個值
但無論怎麼說都隻是基于單庫。
适用場景
分庫分表就倆原因
- 單庫的并發負載過高
- 單庫的資料量過大
除非并發不高，但資料量太大導緻的分庫分表擴容，可用該方案，因為可能每秒最高并發最多就幾百，那麼就走單獨的一個庫和表生成自增主鍵即可。
并發很低，幾百/s，但是資料量大，幾十億的資料，是以需要靠分庫分表來存放海量資料。
2 UUID
本地生成，無需資料庫依賴
- UUID過長，作為主鍵性能太差
- UUID 無序，導緻 B+ 樹索引寫時有着過多的随機寫操作
- 寫時不能産生有順序的 append 操作，而需要 insert，将會讀取整個 B+ 樹節點到記憶體，在插入這條記錄後會将整個節點寫回磁盤，這種操作在記錄占用空間比較大的情況下，性能下降明顯
若你是要随機生成檔案名、編号之類的，可以用UUID，但是作為主鍵是不能的！
UUID.randomUUID().toString().replace(“-”, “”) -> sfsdf23423rr234sfdaf 3 系統時間
擷取目前時間即可。但問題是高并發時，會有重複，這肯定不合适啊，而且還可能修改系統時間呢！
若用該方案，一般将目前時間跟很多其他的業務字段拼接起來，作為一個id。若業務上你可以接受，那也行。
你可以将别的業務字段值跟目前時間拼接起來，組成一個全局唯一的編号，比如訂單編号：
時間戳 + 使用者id + 業務含義編碼
4 snowflake算法（主流方案）
twitter開源的分布式id生成算法，把一個64位的long型的id，1個bit是不用的，用其中的41 bit作為毫秒數，用10 bit作為工作機器id，12 bit作為序列号
-
1 bit：不用
因為二進制裡第一個bit為如果是1，那麼都是負數，但是我們生成的id都是正數，是以第一個bit統一0
- 41 bit：時間戳，機關ms
- 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
- 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;
// 這個是二進制運算，就是 5 bit最多隻能有31個數字，也就是說機器id最多隻能是32以内
private long maxWorkerId = -1L ^ (-1L << workerIdBits);
// 這個是一個意思，就是 5 bit最多隻能有31個數字，機房id最多隻能是32以内
private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
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));
}
if (lastTimestamp == timestamp) {
// 這個意思是說一個毫秒内最多隻能有4096個數字
// 無論你傳遞多少進來，這個位運算保證始終就是在4096這個範圍内，避免你自己傳遞個sequence超過了4096這個範圍
sequence = (sequence + 1) & sequenceMask;
if (sequence == 0) {
timestamp = tilNextMillis(lastTimestamp);
}
} else {
sequence = 0;
}
// 這兒記錄一下最近一次生成id的時間戳，機關是毫秒
lastTimestamp = timestamp;
// 這兒就是将時間戳左移，放到 41 bit那兒；
// 将機房 id左移放到 5 bit那兒；
// 将機器id左移放到5 bit那兒；将序号放最後12 bit；
// 最後拼接起來成一個 64 bit的二進制數字，轉換成 10 進制就是個 long 型
return ((timestamp - twepoch) << timestampLeftShift) | (datacenterId << datacenterIdShift)
| (workerId << workerIdShift) | sequence;
}
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，你換成别的有業務含義的東西也可以的。
參考
- 《Java工程師面試突擊第1季-中華石杉老師》
![GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)