1. 為什么要分庫分表（設計高并發系統的時候，數據庫層面該如何設計）？用過哪些分庫分表中間件？不同的分庫分表中間件都有什么優點和缺點？你們具體是如何對數據庫如何進行垂直拆分或水平拆分的？

面試題剖析

為什么要分庫分表？（設計高并發系統的時候，數據庫層面該如何設計？）

說白了，分庫分表是兩回事兒，大家可別搞混了，可能是光分庫不分表，也可能是光分表不分庫，都有可能。

我先給大家拋出來一個場景。

假如我們現在是一個小創業公司（或者是一個 BAT 公司剛興起的一個新部門），現在注冊用戶就 20 萬，每天活躍用戶就 1 萬，每天單表數據量就 1000，然后高峰期每秒鐘并發請求最多就 10。天，就這種系統，隨便找一個有幾年工作經驗的，然后帶幾個剛培訓出來的，隨便干干都可以。

結果沒想到我們運氣居然這么好，碰上個 CEO 帶著我們走上了康莊大道，業務發展迅猛，過了幾個月，注冊用戶數達到了 2000 萬！每天活躍用戶數 100 萬！每天單表數據量 10 萬條！高峰期每秒最大請求達到 1000！同時公司還順帶著融資了兩輪，進賬了幾個億人民幣啊！公司估值達到了驚人的幾億美金！這是小獨角獸的節奏！

好吧，沒事，現在大家感覺壓力已經有點大了，為啥呢？因為每天多 10 萬條數據，一個月就多 300 萬條數據，現在咱們單表已經幾百萬數據了，馬上就破千萬了。但是勉強還能撐著。高峰期請求現在是 1000，咱們線上部署了幾臺機器，負載均衡搞了一下，數據庫撐 1000QPS 也還湊合。但是大家現在開始感覺有點擔心了，接下來咋整呢......

再接下來幾個月，我的天，CEO 太牛逼了，公司用戶數已經達到 1 億，公司繼續融資幾十億人民幣啊！公司估值達到了驚人的幾十億美金，成為了國內今年最牛逼的明星創業公司！天，我們太幸運了。

但是我們同時也是不幸的，因為此時每天活躍用戶數上千萬，每天單表新增數據多達 50 萬，目前一個表總數據量都已經達到了兩三千萬了！扛不住啊！數據庫磁盤容量不斷消耗掉！高峰期并發達到驚人的 5000~8000！別開玩笑了，哥。我跟你保證，你的系統支撐不到現在，已經掛掉了！

好吧，所以你看到這里差不多就理解分庫分表是怎么回事兒了，實際上這是跟著你的公司業務發展走的，你公司業務發展越好，用戶就越多，數據量越大，請求量越大，那你單個數據庫一定扛不住。

分表

比如你單表都幾千萬數據了，你確定你能扛住么？絕對不行，單表數據量太大，會極大影響你的 sql 執行的性能，到了后面你的 sql 可能就跑的很慢了。一般來說，就以我的經驗來看，單表到幾百萬的時候，性能就會相對差一些了，你就得分表了。

分表是啥意思？就是把一個表的數據放到多個表中，然后查詢的時候你就查一個表。比如按照用戶 id 來分表，將一個用戶的數據就放在一個表中。然后操作的時候你對一個用戶就操作那個表就好了。這樣可以控制每個表的數據量在可控的范圍內，比如每個表就固定在 200 萬以內。

分庫

分庫是啥意思？就是你一個庫一般我們經驗而言，最多支撐到并發 2000，一定要擴容了，而且一個健康的單庫并發值你最好保持在每秒 1000 左右，不要太大。那么你可以將一個庫的數據拆分到多個庫中，訪問的時候就訪問一個庫好了。

這就是所謂的分庫分表，為啥要分庫分表？你明白了吧。

用過哪些分庫分表中間件？不同的分庫分表中間件都有什么優點和缺點？

這個其實就是看看你了解哪些分庫分表的中間件，各個中間件的優缺點是啥？然后你用過哪些分庫分表的中間件。

比較常見的包括：

• cobar
• TDDL
• atlas
• sharding-jdbc
• mycat

cobar

阿里 b2b 團隊開發和開源的，屬于 proxy 層方案。早些年還可以用，但是最近幾年都沒更新了，基本沒啥人用，差不多算是被拋棄的狀態吧。而且不支持讀寫分離、存儲過程、跨庫 join 和分頁等操作。

TDDL

淘寶團隊開發的，屬于 client 層方案。支持基本的 crud 語法和讀寫分離，但不支持 join、多表查詢等語法。目前使用的也不多，因為還依賴淘寶的 diamond 配置管理系統。

atlas

360 開源的，屬于 proxy 層方案，以前是有一些公司在用的，但是確實有一個很大的問題就是社區最新的維護都在 5 年前了。所以，現在用的公司基本也很少了。

sharding-jdbc

當當開源的，屬于 client 層方案。確實之前用的還比較多一些，因為 SQL 語法支持也比較多，沒有太多限制，而且目前推出到了 2.0 版本，支持分庫分表、讀寫分離、分布式 id 生成、柔性事務（最大努力送達型事務、TCC 事務）。而且確實之前使用的公司會比較多一些（這個在官網有登記使用的公司，可以看到從 2017 年一直到現在，是有不少公司在用的），目前社區也還一直在開發和維護，還算是比較活躍，個人認為算是一個現在也可以選擇的方案。

mycat

基于 cobar 改造的，屬于 proxy 層方案，支持的功能非常完善，而且目前應該是非常火的而且不斷流行的數據庫中間件，社區很活躍，也有一些公司開始在用了。但是確實相比于 sharding jdbc 來說，年輕一些，經歷的錘煉少一些。

總結

綜上，現在其實建議考量的，就是 sharding-jdbc 和 mycat，這兩個都可以去考慮使用。

sharding-jdbc 這種 client 層方案的優點在于不用部署，運維成本低，不需要代理層的二次轉發請求，性能很高，但是如果遇到升級啥的需要各個系統都重新升級版本再發布，各個系統都需要耦合 sharding-jdbc 的依賴；

mycat 這種 proxy 層方案的缺點在于需要部署，自己運維一套中間件，運維成本高，但是好處在于對于各個項目是透明的，如果遇到升級之類的都是自己中間件那里搞就行了。

通常來說，這兩個方案其實都可以選用，但是我個人建議中小型公司選用 sharding-jdbc，client 層方案輕便，而且維護成本低，不需要額外增派人手，而且中小型公司系統復雜度會低一些，項目也沒那么多；但是中大型公司最好還是選用 mycat 這類 proxy 層方案，因為可能大公司系統和項目非常多，團隊很大，人員充足，那么最好是專門弄個人來研究和維護 mycat，然后大量項目直接透明使用即可。

你們具體是如何對數據庫如何進行垂直拆分或水平拆分的？

水平拆分的意思，就是把一個表的數據給弄到多個庫的多個表里去，但是每個庫的表結構都一樣，只不過每個庫表放的數據是不同的，所有庫表的數據加起來就是全部數據。水平拆分的意義，就是將數據均勻放更多的庫里，然后用多個庫來抗更高的并發，還有就是用多個庫的存儲容量來進行擴容。

database-split-horizon

垂直拆分的意思，就是把一個有很多字段的表給拆分成多個表，或者是多個庫上去。每個庫表的結構都不一樣，每個庫表都包含部分字段。一般來說，會將較少的訪問頻率很高的字段放到一個表里去，然后將較多的訪問頻率很低的字段放到另外一個表里去。因為數據庫是有緩存的，你訪問頻率高的行字段越少，就可以在緩存里緩存更多的行，性能就越好。這個一般在表層面做的較多一些。

database-split-vertically

這個其實挺常見的，不一定我說，大家很多同學可能自己都做過，把一個大表拆開，訂單表、訂單支付表、訂單商品表。

還有表層面的拆分，就是分表，將一個表變成 N 個表，就是讓每個表的數據量控制在一定范圍內，保證 SQL 的性能。否則單表數據量越大，SQL 性能就越差。一般是 200 萬行左右，不要太多，但是也得看具體你怎么操作，也可能是 500 萬，或者是 100 萬。你的SQL越復雜，就最好讓單表行數越少。

好了，無論分庫還是分表，上面說的那些數據庫中間件都是可以支持的。就是基本上那些中間件可以做到你分庫分表之后，中間件可以根據你指定的某個字段值，比如說 userid，自動路由到對應的庫上去，然后再自動路由到對應的表里去。

你就得考慮一下，你的項目里該如何分庫分表？一般來說，垂直拆分，你可以在表層面來做，對一些字段特別多的表做一下拆分；水平拆分，你可以說是并發承載不了，或者是數據量太大，容量承載不了，你給拆了，按什么字段來拆，你自己想好；分表，你考慮一下，你如果哪怕是拆到每個庫里去，并發和容量都ok了，但是每個庫的表還是太大了，那么你就分表，將這個表分開，保證每個表的數據量并不是很大。

而且這兒還有兩種分庫分表的方式：

• 一種是按照 range 來分，就是每個庫一段連續的數據，這個一般是按比如時間范圍來的，但是這種一般較少用，因為很容易產生熱點問題，大量的流量都打在最新的數據上了。
• 或者是按照某個字段hash一下均勻分散，這個較為常用。

range 來分，好處在于說，擴容的時候很簡單，因為你只要預備好，給每個月都準備一個庫就可以了，到了一個新的月份的時候，自然而然，就會寫新的庫了；缺點，但是大部分的請求，都是訪問最新的數據。實際生產用 range，要看場景。

hash 分發，好處在于說，可以平均分配每個庫的數據量和請求壓力；壞處在于說擴容起來比較麻煩，會有一個數據遷移的過程，之前的數據需要重新計算 hash 值重新分配到不同的庫或表。

2. 現在有一個未分庫分表的系統，未來要分庫分表，如何設計才可以讓系統從未分庫分表動態切換到分庫分表上？

面試題剖析

這個其實從 low 到高大上有好幾種方案，我們都玩兒過，我都給你說一下。

停機遷移方案

我先給你說一個最 low 的方案，就是很簡單，大家伙兒凌晨 12 點開始運維，網站或者 app 掛個公告，說 0 點到早上 6 點進行運維，無法訪問。

接著到 0 點停機，系統停掉，沒有流量寫入了，此時老的單庫單表數據庫靜止了。然后你之前得寫好一個導數的一次性工具，此時直接跑起來，然后將單庫單表的數據嘩嘩嘩讀出來，寫到分庫分表里面去。

導數完了之后，就 ok 了，修改系統的數據庫連接配置啥的，包括可能代碼和 SQL 也許有修改，那你就用最新的代碼，然后直接啟動連到新的分庫分表上去。

驗證一下，ok了，完美，大家伸個懶腰，看看看凌晨 4 點鐘的北京夜景，打個滴滴回家吧。

但是這個方案比較 low，誰都能干，我們來看看高大上一點的方案。

database-shard-method-1

雙寫遷移方案

這個是我們常用的一種遷移方案，比較靠譜一些，不用停機，不用看北京凌晨 4 點的風景。

簡單來說，就是在線上系統里面，之前所有寫庫的地方，增刪改操作，除了對老庫增刪改，都加上對新庫的增刪改，這就是所謂的雙寫，同時寫倆庫，老庫和新庫。

然后系統部署之后，新庫數據差太遠，用之前說的導數工具，跑起來讀老庫數據寫新庫，寫的時候要根據 gmt_modified 這類字段判斷這條數據最后修改的時間，除非是讀出來的數據在新庫里沒有，或者是比新庫的數據新才會寫。簡單來說，就是不允許用老數據覆蓋新數據。

導完一輪之后，有可能數據還是存在不一致，那么就程序自動做一輪校驗，比對新老庫每個表的每條數據，接著如果有不一樣的，就針對那些不一樣的，從老庫讀數據再次寫。反復循環，直到兩個庫每個表的數據都完全一致為止。

接著當數據完全一致了，就 ok 了，基于僅僅使用分庫分表的最新代碼，重新部署一次，不就僅僅基于分庫分表在操作了么，還沒有幾個小時的停機時間，很穩。所以現在基本玩兒數據遷移之類的，都是這么干的。

database-shard-method-2

3. 如何設計可以動態擴容縮容的分庫分表方案？

考點分析

對于分庫分表來說，主要是面對以下問題：

• 選擇一個數據庫中間件，調研、學習、測試；
• 設計你的分庫分表的一個方案，你要分成多少個庫，每個庫分成多少個表，比如 3 個庫，每個庫 4 個表；
• 基于選擇好的數據庫中間件，以及在測試環境建立好的分庫分表的環境，然后測試一下能否正常進行分庫分表的讀寫；
• 完成單庫單表到分庫分表的遷移，雙寫方案；
• 線上系統開始基于分庫分表對外提供服務；
• 擴容了，擴容成 6 個庫，每個庫需要 12 個表，你怎么來增加更多庫和表呢？

這個是你必須面對的一個事兒，就是你已經弄好分庫分表方案了，然后一堆庫和表都建好了，基于分庫分表中間件的代碼開發啥的都好了，測試都 ok 了，數據能均勻分布到各個庫和各個表里去，而且接著你還通過雙寫的方案咔嚓一下上了系統，已經直接基于分庫分表方案在搞了。

那么現在問題來了，你現在這些庫和表又支撐不住了，要繼續擴容咋辦？這個可能就是說你的每個庫的容量又快滿了，或者是你的表數據量又太大了，也可能是你每個庫的寫并發太高了，你得繼續擴容。

這都是玩兒分庫分表線上必須經歷的事兒。

面試題剖析

停機擴容（不推薦）

這個方案就跟停機遷移一樣，步驟幾乎一致，唯一的一點就是那個導數的工具，是把現有庫表的數據抽出來慢慢倒入到新的庫和表里去。但是最好別這么玩兒，有點不太靠譜，因為既然分庫分表就說明數據量實在是太大了，可能多達幾億條，甚至幾十億，你這么玩兒，可能會出問題。

從單庫單表遷移到分庫分表的時候，數據量并不是很大，單表最大也就兩三千萬。那么你寫個工具，多弄幾臺機器并行跑，1小時數據就導完了。這沒有問題。

如果 3 個庫 + 12 個表，跑了一段時間了，數據量都 1~2 億了。光是導 2 億數據，都要導個幾個小時，6 點，剛剛導完數據，還要搞后續的修改配置，重啟系統，測試驗證，10 點才可以搞完。所以不能這么搞。

優化后的方案

一開始上來就是 32 個庫，每個庫 32 個表，那么總共是 1024 張表。

我可以告訴各位同學，這個分法，第一，基本上國內的互聯網肯定都是夠用了，第二，無論是并發支撐還是數據量支撐都沒問題。

每個庫正常承載的寫入并發量是 1000，那么 32 個庫就可以承載32 * 1000 = 32000 的寫并發，如果每個庫承載 1500 的寫并發，32 * 1500 = 48000 的寫并發，接近 5萬/s 的寫入并發，前面再加一個MQ，削峰，每秒寫入 MQ 8 萬條數據，每秒消費 5 萬條數據。

有些除非是國內排名非常靠前的這些公司，他們的最核心的系統的數據庫，可能會出現幾百臺數據庫的這么一個規模，128個庫，256個庫，512個庫。

1024 張表，假設每個表放 500 萬數據，在 MySQL 里可以放 50 億條數據。

每秒的 5 萬寫并發，總共 50 億條數據，對于國內大部分的互聯網公司來說，其實一般來說都夠了。

談分庫分表的擴容，第一次分庫分表，就一次性給他分個夠，32 個庫，1024 張表，可能對大部分的中小型互聯網公司來說，已經可以支撐好幾年了。

一個實踐是利用 32 * 32 來分庫分表，即分為 32 個庫，每個庫里一個表分為 32 張表。一共就是 1024 張表。根據某個 id 先根據 32 取模路由到庫，再根據 32 取模路由到庫里的表。

剛開始的時候，這個庫可能就是邏輯庫，建在一個數據庫上的，就是一個mysql服務器可能建了 n 個庫，比如 32 個庫。后面如果要拆分，就是不斷在庫和 mysql 服務器之間做遷移就可以了。然后系統配合改一下配置即可。

比如說最多可以擴展到32個數據庫服務器，每個數據庫服務器是一個庫。如果還是不夠？最多可以擴展到 1024 個數據庫服務器，每個數據庫服務器上面一個庫一個表。因為最多是1024個表。

這么搞，是不用自己寫代碼做數據遷移的，都交給 dba 來搞好了，但是 dba 確實是需要做一些庫表遷移的工作，但是總比你自己寫代碼，然后抽數據導數據來的效率高得多吧。

哪怕是要減少庫的數量，也很簡單，其實說白了就是按倍數縮容就可以了，然后修改一下路由規則。

這里對步驟做一個總結：

1. 設定好幾臺數據庫服務器，每臺服務器上幾個庫，每個庫多少個表，推薦是 32庫 * 32表，對于大部分公司來說，可能幾年都夠了。
2. 路由的規則，orderId 模 32 = 庫，orderId / 32 模 32 = 表
3. 擴容的時候，申請增加更多的數據庫服務器，裝好 mysql，呈倍數擴容，4 臺服務器，擴到 8 臺服務器，再到 16 臺服務器。
4. 由 dba 負責將原先數據庫服務器的庫，遷移到新的數據庫服務器上去，庫遷移是有一些便捷的工具的。
5. 我們這邊就是修改一下配置，調整遷移的庫所在數據庫服務器的地址。
6. 重新發布系統，上線，原先的路由規則變都不用變，直接可以基于 n 倍的數據庫服務器的資源，繼續進行線上系統的提供服務。

4. 分庫分表之后，id 主鍵如何處理？

考點分析

其實這是分庫分表之后你必然要面對的一個問題，就是 id 咋生成？因為要是分成多個表之后，每個表都是從 1 開始累加，那肯定不對啊，需要一個全局唯一的 id 來支持。所以這都是你實際生產環境中必須考慮的問題。

面試題剖析

基于數據庫的實現方案

數據庫自增 id

這個就是說你的系統里每次得到一個 id，都是往一個庫的一個表里插入一條沒什么業務含義的數據，然后獲取一個數據庫自增的一個 id。拿到這個 id 之后再往對應的分庫分表里去寫入。

這個方案的好處就是方便簡單，誰都會用；缺點就是單庫生成自增 id，要是高并發的話，就會有瓶頸的；如果你硬是要改進一下，那么就專門開一個服務出來，這個服務每次就拿到當前 id 最大值，然后自己遞增幾個 id，一次性返回一批 id，然后再把當前最大 id 值修改成遞增幾個 id 之后的一個值；但是無論如何都是基于單個數據庫。

適合的場景：你分庫分表就倆原因，要不就是單庫并發太高，要不就是單庫數據量太大；除非是你并發不高，但是數據量太大導致的分庫分表擴容，你可以用這個方案，因為可能每秒最高并發最多就幾百，那么就走單獨的一個庫和表生成自增主鍵即可。

設置數據庫 sequence 或者表自增字段步長

可以通過設置數據庫 sequence 或者表的自增字段步長來進行水平伸縮。

比如說，現在有 8 個服務節點，每個服務節點使用一個 sequence 功能來產生 ID，每個 sequence 的起始 ID 不同，并且依次遞增，步長都是 8。

database-id-sequence-step

適合的場景：在用戶防止產生的 ID 重復時，這種方案實現起來比較簡單，也能達到性能目標。但是服務節點固定，步長也固定，將來如果還要增加服務節點，就不好搞了。

UUID

好處就是本地生成，不要基于數據庫來了；不好之處就是，UUID 太長了、占用空間大，作為主鍵性能太差了；更重要的是，UUID 不具有有序性，會導致 B+ 樹索引在寫的時候有過多的隨機寫操作（連續的 ID 可以產生部分順序寫），還有，由于在寫的時候不能產生有順序的 append 操作，而需要進行 insert 操作，將會讀取整個 B+ 樹節點到內存，在插入這條記錄后會將整個節點寫回磁盤，這種操作在記錄占用空間比較大的情況下，性能下降明顯。

適合的場景：如果你是要隨機生成個什么文件名、編號之類的，你可以用 UUID，但是作為主鍵是不能用 UUID 的。

UUID.randomUUID().toString().replace(“-”, “”) -> sfsdf23423rr234sfdaf

獲取系統當前時間

這個就是獲取當前時間即可，但是問題是，并發很高的時候，比如一秒并發幾千，會有重復的情況，這個是肯定不合適的。基本就不用考慮了。

適合的場景：一般如果用這個方案，是將當前時間跟很多其他的業務字段拼接起來，作為一個 id，如果業務上你覺得可以接受，那么也是可以的。你可以將別的業務字段值跟當前時間拼接起來，組成一個全局唯一的編號。

snowflake 算法

snowflake 算法是 twitter 開源的分布式 id 生成算法，采用 Scala 語言實現，是把一個 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，也就是說可以用這個 12 bit 代表的數字來區分同一個毫秒內的 4096 個不同的 id。

0 | 0001100 10100010 10111110 10001001 01011100 00 | 10001 | 1 1001 | 0000 00000000

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 以內），剩下的那個 12 bit序列號，就是如果跟你上次生成 id 的時間還在一個毫秒內，那么會把順序給你累加，最多在 4096 個序號以內。

所以你自己利用這個工具類，自己搞一個服務，然后對每個機房的每個機器都初始化這么一個東西，剛開始這個機房的這個機器的序號就是 0。然后每次接收到一個請求，說這個機房的這個機器要生成一個 id，你就找到對應的 Worker 生成。

利用這個 snowflake 算法，你可以開發自己公司的服務，甚至對于機房 id 和機器 id，反正給你預留了 5 bit + 5 bit，你換成別的有業務含義的東西也可以的。

這個 snowflake 算法相對來說還是比較靠譜的，所以你要真是搞分布式 id 生成，如果是高并發啥的，那么用這個應該性能比較好，一般每秒幾萬并發的場景，也足夠你用了。

關注我！這里只有干貨！
本文原創地址：https://jsbintask.cn/2019/02/17/interview/interview-db-shard/，轉載請注明出處。