歡迎光臨
每天分享高質量文章

支撐百萬併發的資料庫架構如何設計?

 

這篇文章,我們來聊一下對於一個支撐日活百萬用戶的高並系統,他的資料庫架構應該如何設計?

看到這個題目,很多人第一反應就是:分庫分表啊!但是實際上,資料庫層面的分庫分表到底是用來乾什麼的,他的不同的作用如何應對不同的場景,我覺得很多同學可能都沒搞清楚。

用一個創業公司的發展作為背景引入

假如我們現在是一個小創業公司,註冊用戶就 20 萬,每天活躍用戶就 1 萬,每天單表資料量就 1000,然後高峰期每秒鐘併發請求最多就 10。

天哪!就這種系統,隨便找一個有幾年工作經驗的高級工程師,然後帶幾個年輕工程師,隨便乾乾都可以做出來。

因為這樣的系統,實際上主要就是在前期快速的進行業務功能的開發,搞一個單塊系統部署在一臺服務器上,然後連接一個資料庫就可以了。

接著大家就是不停的在一個工程里填充進去各種業務代碼,儘快把公司的業務支撐起來。

如下圖所示:

結果呢,沒想到我們運氣這麼好,碰上個優秀的 CEO 帶著我們走上了康莊大道!

公司業務發展迅猛,過了幾個月,註冊用戶數達到了 2000 萬!每天活躍用戶數 100 萬!每天單表新增資料量達到 50 萬條!高峰期每秒請求量達到 1 萬!

同時公司還順帶著融資了兩輪,估值達到了驚人的幾億美金!一隻朝氣蓬勃的幼年獨角獸的節奏!

好吧,現在大家感覺壓力已經有點大了,為啥呢?因為每天單表新增 50 萬條資料,一個月就多 1500 萬條資料,一年下來單表會達到上億條資料。

經過一段時間的運行,現在咱們單表已經兩三千萬條資料了,勉強還能支撐著。

但是,眼見著系統訪問資料庫的性能怎麼越來越差呢,單表資料量越來越大,拖垮了一些複雜查詢 SQL 的性能啊!

然後高峰期請求現在是每秒 1 萬,咱們的系統在線上部署了 20 台機器,平均每台機器每秒支撐 500 請求,這個還能抗住,沒啥大問題。但是資料庫層面呢?

如果說此時你還是一臺資料庫服務器在支撐每秒上萬的請求,負責任的告訴你,每次高峰期會出現下述問題:

  • 你的資料庫服務器的磁盤 IO、網絡帶寬、CPU 負載、記憶體消耗,都會達到非常高的情況,資料庫所在服務器的整體負載會非常重,甚至都快不堪重負了。

  • 高峰期時,本來你單表資料量就很大,SQL 性能就不太好,這時加上你的資料庫服務器負載太高導致性能下降,就會發現你的 SQL 性能更差了。

  • 最明顯的一個感覺,就是你的系統在高峰期各個功能都運行的很慢,用戶體驗很差,點一個按鈕可能要幾十秒才出來結果。

  • 如果你運氣不太好,資料庫服務器的配置不是特別的高的話,弄不好你還會經歷資料庫宕機的情況,因為負載太高對資料庫壓力太大了。

多台服務器分庫支撐高併發讀寫

首先我們先考慮第一個問題,資料庫每秒上萬的併發請求應該如何來支撐呢?

要搞清楚這個問題,先得明白一般資料庫部署在什麼配置的服務器上。通常來說,假如你用普通配置的服務器來部署資料庫,那也起碼是 16 核 32G 的機器配置。

這種非常普通的機器配置部署的資料庫,一般線上的經驗是:不要讓其每秒請求支撐超過 2000,一般控制在 2000 左右。

控制在這個程度,一般資料庫負載相對合理,不會帶來太大的壓力,沒有太大的宕機風險。

所以首先第一步,就是在上萬併發請求的場景下,部署個 5 台服務器,每台服務器上都部署一個資料庫實體。

然後每個資料庫實體里,都創建一個一樣的庫,比如說訂單庫。此時在 5 台服務器上都有一個訂單庫,名字可以類似為:db_order_01,db_order_02,等等。

然後每個訂單庫里,都有一個相同的表,比如說訂單庫里有訂單信息表,那麼此時 5 個訂單庫里都有一個訂單信息表。

比如 db_order_01 庫里就有一個 tb_order_01 表,db_order_02 庫里就有一個 tb_order_02 表。

這就實現了一個基本的分庫分表的思路,原來的一臺資料庫服務器變成了 5 台資料庫服務器,原來的一個庫變成了 5 個庫,原來的一張表變成了 5 個表。

然後你在寫入資料的時候,需要借助資料庫中間件,比如 sharding-jdbc,或者是 mycat,都可以。

你可以根據比如訂單 id 來 hash 後按 5 取模,比如每天訂單表新增 50 萬資料,此時其中 10 萬條資料會落入 db_order_01 庫的 tb_order_01 表,另外 10 萬條資料會落入 db_order_02 庫的 tb_order_02 表,以此類推。

這樣就可以把資料均勻分散在 5 台服務器上了,查詢的時候,也可以通過訂單 id 來 hash 取模,去對應的服務器上的資料庫里,從對應的表裡查詢那條資料出來即可。

依據這個思路畫出的圖如下所示,大家可以看看:

做這一步有什麼好處呢?第一個好處,原來比如訂單表就一張表,這個時候不就成了 5 張表了麽,那麼每個表的資料就變成 1/5 了。

假設訂單表一年有 1 億條資料,此時 5 張表裡每張表一年就 2000 萬資料了。

那麼假設當前訂單表裡已經有 2000 萬資料了,此時做了上述拆分,每個表裡就只有 400 萬資料了。

而且每天新增 50 萬資料的話,那麼每個表才新增 10 萬資料,這樣是不是初步緩解了單表資料量過大影響系統性能的問題?

另外就是每秒 1 萬請求到 5 台資料庫上,每台資料庫就承載每秒 2000 的請求,是不是一下子把每台資料庫服務器的併發請求降低到了安全範圍內?

這樣,降低了資料庫的高峰期負載,同時還保證了高峰期的性能。

大量分表來保證海量資料下的查詢性能

但是上述的資料庫架構還有一個問題,那就是單表資料量還是過大,現在訂單表才分為了 5 張表,那麼如果訂單一年有 1 億條,每個表就有 2000 萬條,這也還是太大了。

所以還應該繼續分表,大量分表。比如可以把訂單表一共拆分為 1024 張表,這樣 1 億資料量的話,分散到每個表裡也就才 10 萬量級的資料量,然後這上千張表分散在 5 台資料庫里就可以了。

在寫入資料的時候,需要做兩次路由,先對訂單 id hash 後對資料庫的數量取模,可以路由到一臺資料庫上,然後再對那台資料庫上的表數量取模,就可以路由到資料庫上的一個表裡了。

通過這個步驟,就可以讓每個表裡的資料量非常小,每年 1 億資料增長,但是到每個表裡才 10 萬條資料增長,這個系統運行 10 年,每個表裡可能才百萬級的資料量。

這樣可以一次性為系統未來的運行做好充足的準備,看下麵的圖,一起來感受一下:

全域性唯一 id 如何生成

在分庫分表之後你必然要面對的一個問題,就是 id 咋生成?因為要是一個表分成多個表之後,每個表的 id 都是從 1 開始累加自增長,那肯定不對啊。

舉個例子,你的訂單表拆分為了 1024 張訂單表,每個表的 id 都從 1 開始累加,這個肯定有問題了!

你的系統就沒辦法根據表主鍵來查詢訂單了,比如 id = 50 這個訂單,在每個表裡都有!

所以此時就需要分佈式架構下的全域性唯一 id 生成的方案了,在分庫分表之後,對於插入資料庫中的核心 id,不能直接簡單使用表自增 id,要全域性生成唯一 id,然後插入各個表中,保證每個表內的某個 id,全域性唯一。

比如說訂單表雖然拆分為了 1024 張表,但是 id = 50 這個訂單,只會存在於一個表裡。

那麼如何實現全域性唯一 id 呢?有以下幾種方案:

方案一:獨立資料庫自增 id

這個方案就是說你的系統每次要生成一個 id,都是往一個獨立庫的一個獨立表裡插入一條沒什麼業務含義的資料,然後獲取一個資料庫自增的一個 id。拿到這個 id 之後再往對應的分庫分表裡去寫入。

比如說你有一個 auto_id 庫,裡面就一個表,叫做 auto_id 表,有一個 id 是自增長的。

那麼你每次要獲取一個全域性唯一 id,直接往這個表裡插入一條記錄,獲取一個全域性唯一 id 即可,然後這個全域性唯一 id 就可以插入訂單的分庫分表中。

這個方案的好處就是方便簡單,誰都會用。缺點就是單庫生成自增 id,要是高併發的話,就會有瓶頸的,因為 auto_id 庫要是承載個每秒幾萬併發,肯定是不現實的了。

方案二:UUID

這個每個人都應該知道吧,就是用 UUID 生成一個全域性唯一的 id。

好處就是每個系統本地生成,不要基於資料庫來了。不好之處就是,UUID 太長了,作為主鍵性能太差了,不適合用於主鍵。

如果你是要隨機生成個什麼檔案名了,編號之類的,你可以用 UUID,但是作為主鍵是不能用 UUID 的。

方案三:獲取系統當前時間

這個方案的意思就是獲取當前時間作為全域性唯一的 id。但是問題是,併發很高的時候,比如一秒併發幾千,會有重覆的情況,這個肯定是不合適的。

一般如果用這個方案,是將當前時間跟很多其他的業務欄位拼接起來,作為一個 id,如果業務上你覺得可以接受,那麼也是可以的。

你可以將別的業務欄位值跟當前時間拼接起來,組成一個全域性唯一的編號,比如說訂單編號:時間戳 + 用戶 id + 業務含義編碼。

方案四:SnowFlake 演算法的思想分析

SnowFlake 演算法,是 Twitter 開源的分佈式 id 生成演算法。其核心思想就是:使用一個 64 bit 的 long 型的數字作為全域性唯一 id。

這 64 個 bit 中,其中 1 個 bit 是不用的,然後用其中的 41 bit 作為毫秒數,用 10 bit 作為工作機器 id,12 bit 作為序列號。

給大家舉個例子吧,比如下麵那個 64 bit 的 long 型數字:

  • 第一個部分,是 1 個 bit:0,這個是無意義的。

  • 第二個部分是 41 個 bit:表示的是時間戳。

  • 第三個部分是 5 個 bit:表示的是機房 id,10001。

  • 第四個部分是 5 個 bit:表示的是機器 id,1 1001。

  • 第五個部分是 12 個 bit:表示的序號,就是某個機房某台機器上這一毫秒內同時生成的 id 的序號,0000 00000000。

①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。

簡單來說,你的某個服務假設要生成一個全域性唯一 id,那麼就可以發送一個請求給部署了 SnowFlake 演算法的系統,由這個 SnowFlake 演算法系統來生成唯一 id。

這個 SnowFlake 演算法系統首先肯定是知道自己所在的機房和機器的,比如機房 id = 17,機器 id = 12。

接著 SnowFlake 演算法系統接收到這個請求之後,首先就會用二進制位運算的方式生成一個 64 bit 的 long 型 id,64 個 bit 中的第一個 bit 是無意義的。

接著 41 個 bit,就可以用當前時間戳(單位到毫秒),然後接著 5 個 bit 設置上這個機房 id,還有 5 個 bit 設置上機器 id。

最後再判斷一下,當前這台機房的這台機器上這一毫秒內,這是第幾個請求,給這次生成 id 的請求累加一個序號,作為最後的 12 個 bit。

最終一個 64 個 bit 的 id 就出來了,類似於:

這個演算法可以保證說,一個機房的一臺機器上,在同一毫秒內,生成了一個唯一的 id。可能一個毫秒內會生成多個 id,但是有最後 12 個 bit 的序號來區分開來。

下麵我們簡單看看這個 SnowFlake 演算法的一個代碼實現,這就是個示例,大家如果理解了這個意思之後,以後可以自己嘗試改造這個演算法。

總之就是用一個 64 bit 的數字中各個 bit 位來設置不同的標誌位,區分每一個 id。

SnowFlake 演算法的實現代碼如下:

public class IdWorker {
  private long workerId; // 這個就是代表了機器id
  private long datacenterId; // 這個就是代表了機房id
  private long sequence; // 這個就是代表了一毫秒內生成的多個id的最新序號
  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));
    }
    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 <  // 這個是一個意思,就是5 bit最多只能有31個數字,機房id最多只能是32以內
  private long maxDatacenterId = -1L ^ (-1L <  private long sequenceBits = 12L;
  private long workerIdShift = sequenceBits;
  private long datacenterIdShift = sequenceBits + workerIdBits;
  private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
  private long sequenceMask = -1L ^ (-1L <  private long lastTimestamp = -1L;
  public long getWorkerId(){
    return workerId;
  }
  public long getDatacenterId() {
    return datacenterId;
  }
  public long getTimestamp() {
    return System.currentTimeMillis();
  }
  // 這個是核心方法,通過呼叫nextId()方法,讓當前這台機器上的snowflake演算法程式生成一個全域性唯一的id
  public synchronized long nextId() {
    // 這兒就是獲取當前時間戳,單位是毫秒
    long timestamp = timeGen();
    if (timestamp       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));
    }

    // 下麵是說假設在同一個毫秒內,又發送了一個請求生成一個id
    // 這個時候就得把seqence序號給遞增1,最多就是4096
    if (lastTimestamp == timestamp) {

      // 這個意思是說一個毫秒內最多只能有4096個數字,無論你傳遞多少進來,
      //這個位運算保證始終就是在4096這個範圍內,避免你自己傳遞個sequence超過了4096這個範圍
      sequence = (sequence + 1) & sequenceMask; 
      if (sequence == 0) {
        timestamp = tilNextMillis(lastTimestamp);
      }

    } else {
      sequence = 0;
    }
    // 這兒記錄一下最近一次生成id的時間戳,單位是毫秒
    lastTimestamp = timestamp;
    // 這兒就是最核心的二進制位運算操作,生成一個64bit的id
    // 先將當前時間戳左移,放到41 bit那兒;將機房id左移放到5 bit那兒;將機器id左移放到5 bit那兒;將序號放最後12 bit
    // 最後拼接起來成一個64 bit的二進制數字,轉換成10進制就是個long型
    return ((timestamp - twepoch) <        (datacenterId <        (workerId <  }
  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());
    }
  }
}

SnowFlake 演算法一個小小的改進思路:其實在實際的開發中,這個SnowFlake演算法可以做一點點改進。

因為大家可以考慮一下,我們在生成唯一 id 的時候,一般都需要指定一個表名,比如說訂單表的唯一 id。

所以上面那 64 個 bit 中,代表機房的那 5 個 bit,可以使用業務表名稱來替代,比如用 00001 代表的是訂單表。

因為其實很多時候,機房並沒有那麼多,所以那 5 個 bit 用做機房 id 可能意義不是太大。

這樣就可以做到,SnowFlake 演算法系統的每一臺機器,對一個業務表,在某一毫秒內,可以生成一個唯一的 id,一毫秒內生成很多 id,用最後 12 個 bit 來區分序號對待。

讀寫分離來支撐按需擴容以及性能提升

這個時候整體效果已經挺不錯了,大量分表的策略保證可能未來 10 年,每個表的資料量都不會太大,這可以保證單表內的 SQL 執行效率和性能。

然後多台資料庫的拆分方式,可以保證每台資料庫服務器承載一部分的讀寫請求,降低每台服務器的負載。

但是此時還有一個問題,假如說每台資料庫服務器承載每秒 2000 的請求,然後其中 400 請求是寫入,1600 請求是查詢。

也就是說,增刪改的 SQL 才占到了 20% 的比例,80% 的請求是查詢。此時假如說隨著用戶量越來越大,又變成每台服務器承載 4000 請求了。

那麼其中 800 請求是寫入,3200 請求是查詢,如果說你按照目前的情況來擴容,就需要增加一臺資料庫服務器。

但是此時可能就會涉及到表的遷移,因為需要遷移一部分表到新的資料庫服務器上去,是不是很麻煩?

其實完全沒必要,資料庫一般都支持讀寫分離,也就是做主從架構。

寫入的時候寫入主資料庫服務器,查詢的時候讀取從資料庫服務器,就可以讓一個表的讀寫請求分開落地到不同的資料庫上去執行。

這樣的話,假如寫入主庫的請求是每秒 400,查詢從庫的請求是每秒 1600。

那麼圖大概如下所示:

寫入主庫的時候,會自動同步資料到從庫上去,保證主庫和從庫資料一致。

然後查詢的時候都是走從庫去查詢的,這就通過資料庫的主從架構實現了讀寫分離的效果了。

現在的好處就是,假如說現在主庫寫請求增加到 800,這個無所謂,不需要擴容。然後從庫的讀請求增加到了 3200,需要擴容了。

這時,你直接給主庫再掛載一個新的從庫就可以了,兩個從庫,每個從庫支撐 1600 的讀請求,不需要因為讀請求增長來擴容主庫。

實際上線上生產你會發現,讀請求的增長速度遠遠高於寫請求,所以讀寫分離之後,大部分時候就是擴容從庫支撐更高的讀請求就可以了。

而且另外一點,對同一個表,如果你既寫入資料(涉及加鎖),還從該表查詢資料,可能會牽扯到鎖衝突等問題,無論是寫性能還是讀性能,都會有影響。

所以一旦讀寫分離之後,對主庫的表就僅僅是寫入,沒任何查詢會影響他,對從庫的表就僅僅是查詢。

高併發下的資料庫架構設計總結

從大的一個簡化的角度來說,高併發的場景下,資料庫層面的架構肯定是需要經過精心的設計的。

尤其是涉及到分庫來支撐高併發的請求,大量分表保證每個表的資料量別太大,讀寫分離實現主庫和從庫按需擴容以及性能保證。

這篇文章就是從一個大的角度來梳理了一下思路,各位同學可以結合自己公司的業務和專案來考慮自己的系統如何做分庫分表。

另外就是,具體的分庫分表落地的時候,需要借助資料庫中間件來實現分庫分表和讀寫分離,大家可以自己參考 Sharding-JDBC 或者 MyCAT 的官網即可,裡面的文件都有詳細的使用描述。

 

轉載自:石杉的架構筆記

    赞(0)

    分享創造快樂