System Design Interview Vol. 2 · 第 12 章Triton 覆蓋度:🟢 高Triton 線

Digital Wallet
轉帳的難處不在快,在「兩邊一起改」

原書要做每秒 100 萬筆轉帳的錢包:從 Redis 分片出發,換成資料庫加 2PC / TC/C / Saga,最後走到 event sourcing + CQRS + Raft。Triton 的看法正好相反:錢放 RDBMS、用一句有條件的 UPDATE 扣款、照順序上鎖、先 scale up;event sourcing 躲不掉這些難題。

給文組

全程用「家裡的存錢筒」比喻:媽媽負責把錢從哥哥的存錢筒搬到妹妹的,搬到一半電話響了會怎樣?一階一階爬 14 個概念;頁首標 延伸基礎 的頁是補基礎,懂的人可以跳過。

給工程師

第 4–47 頁完整講原書(30 張圖、5 個表),後面是 Triton 的觀點,最後一頁列出所有出處(materials/core)與頁碼對照。

標籤怎麼看

📖 原書 🗣️ Triton 本人說 📝 上課筆記 🔭 依 Triton 原則推論 📅 2026 補充

先用生活理解兩個存錢筒

媽媽把 $1 從哥哥的存錢筒搬到妹妹的,搬到一半電話響了

家裡原書的錢包
哥哥、妹妹的存錢筒帳戶餘額(account balance)
媽媽Wallet service:收到轉帳指令,去改兩個餘額
存錢筒放在不同房間餘額分散在不同的 Redis / DB 節點
電話響了,媽媽走開Wallet service 在兩次更新之間當機
「先記一筆,錯了再補記一筆」TC/C、Saga 的補償交易
每一筆進出都寫進流水帳Event sourcing:只記事件,餘額用重播算出來

兩個存錢筒的錢加起來應該永遠一樣。搬到一半走開,哥哥少了 $1、妹妹沒多 $1,這 $1 就「不見了」。整章都在處理這件事;哥哥、妹妹、媽媽會從頭用到尾。

學習地圖本章的概念階梯

今天爬 14 階。每一階只用前面講過的東西。

  1. 1TPS每秒幾筆轉帳
  2. 2Redis斷電就擦掉的白板
  3. 3sharding存錢筒分房間放
  4. 4transaction一起算或都不算
  5. 52PC先問兩邊可以嗎
  6. 6TC/C先做,錯了再補
  7. 7Saga排好順序倒著補
  8. 8event sourcing只記每一筆
  9. 9reproduci­bility誰重算都一樣
  10. 10CQRS寫一本、查另一本
  11. 11snapshot月底抄結餘
  12. 12Raft抄三份過半數
  13. 13race condition同時看、同時扣
  14. 14deadlock互相等鑰匙

第 1–4 階 · 一筆轉帳,兩個存錢筒

要回答:存錢筒放在兩個房間,為什麼就會出事?

第 5–7 階 · 兩個房間一起改

要回答:原書的 2PC、TC/C、Saga 差在哪?

第 8–11 階 · 只記流水帳

要回答:怎麼證明每一塊錢的來龍去脈?

第 12 階 · 流水帳不怕壞

要回答:一台壞了怎麼辦?原書最後長怎樣?

第 13–14 階 · Triton 的修法

要回答:為什麼一句 UPDATE 就夠,還要照順序鎖?

全程只用一個家:哥哥、妹妹的存錢筒(虛構)

哥哥的存錢筒 = 帳戶 A妹妹的存錢筒 = 帳戶 C媽媽 = wallet service兩個房間 = 兩台機器家裡的流水帳 = event list月底抄的結餘 = snapshot

一開始哥哥、妹妹各有 $5,加起來 $10;原書的例子是 A 轉 $1 給 C。每爬 3–4 階,有一頁「到這裡你已經會了」。

原書開場Figure 1–2

錢包能存錢、付款,也能直接轉給同平台的其他人

這一步要解決的問題錢包到底在做什麼?這一章只管其中哪一件事?

📖 原書 Figure 1Digital wallet(依原書內容重繪)

📖 原書 支付平台通常提供數位錢包:從銀行卡把錢存進錢包,線上購物時選擇用錢包裡的錢付款(Figure 1)。

📖 原書 花錢不是唯一功能。像 PayPal 這樣的平台,可以直接把錢轉到同一平台上其他人的錢包。比起銀行間轉帳,錢包之間的轉帳更快,而且通常不收額外手續費(Figure 2)。

這場面試的題目

設計一個支援跨錢包餘額轉帳的數位錢包後端。和上一章的差別:錢不離開平台,沒有外部 PSP,A 少多少、B 就多多少。

延伸基礎第 1 階 · TPS懂的人可以跳過

  1. TPS
  2. Redis
  3. sharding
  4. transaction
  5. 2PC
  6. TC/C
  7. Saga
  8. event sourcing
  9. reproducibility
  10. CQRS
  11. snapshot
  12. Raft
  13. race condition
  14. deadlock

媽媽每秒要轉 10 筆零用錢,要請幾位幫手?

① 先想像

媽媽每轉一筆零用錢,要動兩個存錢筒:從一個拿出來、放進另一個。一位幫手每秒只動得了固定幾次。

你猜猜看:每秒轉 10 筆,每秒要動幾次存錢筒?

③ 這叫做 TPS、node

TPS(transactions per second):每秒幾筆交易,跟 QPS 是同一個想法。node:一台機器,就是一位幫手。

④ 跟這章的關係

原書:100 萬 TPS × 2 ÷ 每台 1,000 = 2,000 台(第 7 頁)。

② 動手玩:算算看要請幾位

原書 Step 1釐清需求

只做轉帳,但每秒 100 萬筆,還要能「重播」

這一步要解決的問題要做多大、多準?面試官最在意的,其實是「錢算錯時追得到原因」。

📖 原書 應徵者 × 面試官

應徵者問面試官答
只做兩個錢包之間的餘額轉帳?還要別的功能嗎?只做餘額轉帳
系統要支援每秒幾筆交易(TPS)?假設 1,000,000 TPS(每秒 100 萬筆,第 5 頁)
錢包對正確性要求很嚴格,假設 transactional guarantees 就足夠?聽起來不錯
需要證明正確性嗎?好問題。正確性通常只能在交易完成後驗證,例如拿內部紀錄和銀行對帳單比。但對帳只告訴你有差異,不告訴你差異怎麼來的。所以希望系統有可重現性:能從頭重播資料,重建歷史餘額
可用性 99.99%?聽起來不錯
要考慮外匯嗎?不,不在範圍內

📖 原書 需求總結

  • 支援兩個數位錢包之間的餘額轉帳
  • 支援 1,000,000 TPS
  • 可靠性至少 99.99%
  • 支援交易(transactions)
  • 支援可重現性(reproducibility)

文組翻譯:可重現性

月底發現存錢筒少了 $3。只有「現在有多少」的話,你只知道少了;如果有一本從第一天開始的流水帳,就能一筆一筆重算,找到是哪一天哪一筆出錯。

這兩個需求(1M TPS、可重現)會決定原書後半的所有設計。Triton 對兩者都有話要說,見第 59、60 頁。

原書 Step 1Back-of-the-envelope estimation · Table 1

一筆轉帳是兩個操作:100 萬 TPS 其實是 200 萬

這一步要解決的問題每秒 100 萬筆轉帳,需要幾台機器?

📖 原書 談 TPS 就代表會用交易型資料庫。今天在一般資料中心節點上跑的關聯式資料庫,每秒可以做幾千筆交易(原書引 TPC-E 的效能基準)。假設一個資料庫節點撐 1,000 TPS,100 萬 TPS 就要 1,000 個節點。

📖 原書 但這樣算不太準:每個轉帳指令要做兩個操作,從一個帳戶扣款、存入另一個帳戶。所以每秒 100 萬筆轉帳,系統實際要處理到 200 萬 TPS,也就是 2,000 個節點。

📖 原書 Table 1:硬體不變的前提下,單一節點每秒能處理的交易越多,需要的節點越少、硬體成本越低。所以設計目標之一是提升單一節點能處理的交易數。

📖 Table 1 Mapping between per-node TPS and node number
Per-node TPSNode Number
10020,000
1,0002,000
10,000200

原書 Step 2API design

只有一支 API:POST /v1/wallet/balance_transfer

這一步要解決的問題外面要怎麼跟錢包說「請把 $1 從 A 轉給 C」?

📖 原書 Step 2 會談:API 設計,以及三種高階設計:① 簡單的 in-memory 方案、② 以資料庫為基礎的分散式交易方案、③ 具可重現性的 event sourcing 方案。API 採用 RESTful 慣例,這次面試只需要一支:

APIDetail
POST /v1/wallet/balance_transferTransfer balance from one wallet to another
📖 原書 Request parameters
FieldDescriptionType
from_accountThe debit account 借方帳戶string
to_accountThe credit account 貸方帳戶string
amountThe amount of money 金額string
currencyThe currency type 貨幣類型string (ISO 4217)
transaction_idID used for deduplication 用於去重(同一筆按兩次只算一次,idempotency)uuid

📖 原書 Sample response body

{
"Status": "success"
"Transaction_id": "01589980-2664-11ec-9621-0242ac130002"
}

照原書排版(原書兩行之間沒有逗號)。

📖 原書 amount 為什麼是 string

理由在 Payment System 那一章:不同協定、軟硬體的精度不同,用 double 可能有 rounding error。原書接著說:實務上很多人仍用 float 或 double,因為幾乎所有語言和資料庫都支援;只要了解可能失去精度的風險,這是合理的選擇。

最後那句話 Triton 不會同意:「永遠用上十進制(Decimal)」,見第 61 頁。

延伸基礎第 2 階 · Redis懂的人可以跳過

  1. TPS
  2. Redis
  3. sharding
  4. transaction
  5. 2PC
  6. TC/C
  7. Saga
  8. event sourcing
  9. reproducibility
  10. CQRS
  11. snapshot
  12. Raft
  13. race condition
  14. deadlock

冰箱上的白板寫得快,可是停電就擦掉了

① 先想像

媽媽把每個人的錢寫在冰箱的電子白板上,改起來很快。可是這塊白板一停電就清空,所以媽媽每寫 10 筆,就拍一張照片收進抽屜。

你猜猜看:每 10 筆拍一次照,寫到第 25 筆時停電。哪些紀錄不見了?

③ 這叫做 in-memory、Redis

in-memory:資料放在記憶體(白板),快,但斷電會不見;磁碟就是抽屜(02 章)。Redis:最常見的 in-memory 資料庫(04 章)。

④ 跟這章的關係

原書第一個設計把餘額放在 Redis(第 11 頁)。Triton 那邊:跟錢有關千萬不要(第 50 頁)。

② 動手玩:白板 + 抽屜

0白板上的紀錄0已拍照存檔0停電後不見

延伸基礎第 3 階 · sharding懂的人可以跳過

  1. TPS
  2. Redis
  3. sharding
  4. transaction
  5. 2PC
  6. TC/C
  7. Saga
  8. event sourcing
  9. reproducibility
  10. CQRS
  11. snapshot
  12. Raft
  13. race condition
  14. deadlock

存錢筒太多,一個房間放不下:照編號分到不同房間

① 先想像

親戚的小孩一共 16 個存錢筒,一個房間放不下,就照編號分到幾個房間。媽媽轉帳時,兩個存錢筒常常不在同一間。

你猜猜看:分成 4 個房間,隨便挑兩個存錢筒轉帳,兩個剛好在同一間的機會大約是?

③ 這叫做 sharding、partition

sharding:資料太多,照規則分給好幾台機器放(01 章)。partition:分出來的每一份。規則常用「編號除以 N 的餘數」(hash,05 章)。

④ 跟這章的關係

原書 Figure 3 用 hashCode() % 7 分(第 11 頁)。跨房間的轉帳,就是整章所有麻煩的來源。

② 動手玩:分幾間,就有多少轉帳要跨房間

原書 Step 2 · 設計 ①In-memory sharding solution · Figure 3

餘額放 Redis,用 hash 分片,Zookeeper 記住誰在哪

這一步要解決的問題最簡單的做法:餘額放在很快的白板(Redis)上,分到很多台。哪裡會出錯?

📖 原書 Figure 3In-memory solution(依原書內容重繪)
$3A + B + C

📖 原書 錢包要維護每個帳戶的餘額,<user, balance> 適合用 map(hash table、key-value store)。記憶體儲存常見選擇是 Redis。一個 Redis 節點撐不住 100 萬 TPS,所以建 Redis cluster,把帳戶平均分到各節點:partitioning / sharding。分到 N 個分區:key 的 hash 對 N 取餘數。

String accountID = "A";
Int partitionNumber = 7;
Int myPartition = accountID.hashCode() % partitionNumber;

📖 原書 分區數量和所有 Redis 節點的位址放在集中的地方:用 Zookeeper 當高可用的設定儲存。最後一個元件是 wallet service:① 接收轉帳指令 ② 驗證指令 ③ 有效的話更新兩個帳戶的餘額,而它們很可能在不同的 Redis 節點。Wallet service 是 stateless(身上不記東西),容易水平擴展。

面試官:這個設計可行,但不符合正確性要求。每次轉帳要更新兩個 Redis 節點,無法保證兩次都成功:wallet service 在第一次更新後、第二次前當機,轉帳就不完整。兩次更新必須在單一的 atomic transaction 裡完成。

延伸基礎第 4 階 · transaction懂的人可以跳過

  1. TPS
  2. Redis
  3. sharding
  4. transaction
  5. 2PC
  6. TC/C
  7. Saga
  8. event sourcing
  9. reproducibility
  10. CQRS
  11. snapshot
  12. Raft
  13. race condition
  14. deadlock

同一本帳簿上的兩行:要嘛一起算,要嘛都不算

① 先想像

媽媽在帳簿上寫「哥哥 −$1」「妹妹 +$1」,最後簽名才算數。還沒簽名就停電,寫了的行全部作廢。

你猜猜看:寫完「哥哥 −$1」、還沒寫「妹妹 +$1」就停電。隔天帳簿怎麼算?

③ 這叫做 transaction、commit

transaction:綁在一起的一組修改,要嘛全部生效、要嘛全部不算(rollback)。commit:簽名,讓這一組生效。另見 07 章、22 章。

④ 跟這章的關係

一台資料庫裡,一個 transaction 就保證了轉帳。可是兩個存錢筒在兩台機器上,一本帳簿管不到(第 14 頁)。

② 動手玩:照 ①②③ 寫,隨時停電

$5哥哥$5妹妹$10加起來

到這裡你已經會了小結 1 / 5

  1. TPS
  2. Redis
  3. sharding
  4. transaction
  5. 2PC
  6. TC/C
  7. Saga
  8. event sourcing
  9. reproducibility
  10. CQRS
  11. snapshot
  12. Raft
  13. race condition
  14. deadlock

到這裡你已經會了:存錢筒放在兩個房間,為什麼會出事

下一階要解決的問題

兩個房間各有一本帳簿,怎麼讓兩邊一起改?原書給了三個答案:2PC、TC/C、Saga。

原書 Step 2 · 設計 ②Distributed transactions · Database sharding · Figure 4

把 Redis 換成關聯式資料庫:每個節點都有 transaction 了,還不夠

這一步要解決的問題換成有 transaction 的資料庫,兩個房間的問題解決了嗎?

📖 原書 Figure 4Relational database(依原書內容重繪)

📖 原書 怎麼讓兩個不同儲存節點上的更新成為 atomic?第一步:把每個 Redis 節點換成具 transaction 能力的關聯式資料庫節點。這次 A、B、C 被分到三個關聯式資料庫。

📖 原書 只用交易型資料庫只能解決一部分問題:一個轉帳指令很可能要更新兩個不同資料庫裡的兩個帳戶,無法保證兩個更新在同一時間點執行。如果 wallet service 更新完第一個帳戶就重啟,怎麼確保第二個帳戶也會更新?

📖 原書 分散式交易的兩種做法

  • 低階方案:靠資料庫本身,最常用的是 two-phase commit(2PC)
  • 高階方案:在應用層的商業邏輯裡做,例如 TC/C 和 Saga

🏠 存錢筒換成「有鎖的保險箱」:每個保險箱自己開關都安全,但兩個保險箱還是在兩個房間。

延伸基礎第 5 階 · 2PC懂的人可以跳過

  1. TPS
  2. Redis
  3. sharding
  4. transaction
  5. 2PC
  6. TC/C
  7. Saga
  8. event sourcing
  9. reproducibility
  10. CQRS
  11. snapshot
  12. Raft
  13. race condition
  14. deadlock

兩個房間各一本帳簿:先問兩邊「可以嗎」,都說好才一起簽

① 先想像

媽媽先打電話問哥哥房間、再問妹妹房間:「可以嗎?」說可以的人就先按住存錢筒,不讓別人動。兩邊都說可以,媽媽才喊「簽」。

你猜猜看:兩邊都說「可以」、都按住了,媽媽卻突然昏倒。哥哥能自己放手嗎?

③ 這叫做 2PC、coordinator

2PC(two-phase commit):第一階段問「準備好了嗎」(prepare),全部說好,第二階段才一起 commit。coordinator:打電話問的那個人,就是媽媽。

④ 跟這章的關係

原書的「低階方案」(第 16 頁)。22 章用婚禮講過同一件事:22 章第 39 頁。

② 動手玩:三種情況

    0 秒存錢筒被按住多久—結果

    原書 Step 2 · 低階方案Two-phase commit · Figure 5–6

    2PC:先問大家「準備好了嗎」,全部說好才一起 commit

    這一步要解決的問題兩台資料庫,怎麼做到「要嘛一起改,要嘛都不改」?

    📖 原書 Figure 5Two-phase commit(原書標 source [5]:DDIA;粗紅線=持有鎖;依原書內容重繪)

    📖 原書 分散式系統裡,一個交易可能牽涉多個節點上的多個程序。2PC 顧名思義有兩個階段:

    1. Coordinator(這裡是 wallet service)照常對多個資料庫讀寫,資料庫 A 與 C 都被鎖住
    2. 應用程式要 commit 時,coordinator 請所有資料庫 prepare
    3. 第二階段,coordinator 收集回覆:全部回「是」→ 請大家 commit;任何一個回「否」→ 請大家 abort

    📖 原書 為什麼叫「低階」?兩個問題

    • prepare 階段需要修改資料庫交易才做得到,例如協調異質資料庫的 X/Open XA 標準(讓不同牌子的資料庫一起做 2PC)
    • 效能差:等其他節點的訊息時,鎖可能被持有很久
    • Coordinator 是單點故障(Figure 6):它在 prepare 後當機,資料庫回了 yes 卻沒人告訴它們要 commit 還是 abort

    🏠 媽媽先把兩個存錢筒都按住,問「可以嗎」,兩邊都說可以才一起放手。媽媽昏倒的話,兩隻手都一直按著。

    延伸基礎第 6 階 · TC/C懂的人可以跳過

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    先真的把錢拿出來;妹妹那邊不收,再走回去放回去

    ① 先想像

    媽媽不按住兩邊。她先從哥哥的存錢筒拿出 $1(這一步已經做完了)。妹妹那邊 OK 就放進去;不 OK,就走回去把 $1 放回哥哥那裡。

    你猜猜看:$1 已經拿出來、還沒放進妹妹那邊時,有人來數兩個存錢筒,加起來是?

    ③ 這叫做 TC/C、compensating transaction

    TC/C(Try-Confirm/Cancel):先做(Try),再確認(Confirm)或反向補回(Cancel)。compensating transaction:用一個反向動作,抵銷已經做完的事。

    ④ 跟這章的關係

    原書的「高階方案」之一(第 18–24 頁)。比 2PC 少按住,代價是中間看得到不平衡。

    ② 動手玩:先做,再確認或補回

    原書 Step 2 · 高階方案Try-Confirm/Cancel · Table 2 · Figure 7

    TC/C:第一階段先「做」,第二階段確認,或反向補回去

    這一步要解決的問題不想一直按住兩邊(鎖),能不能先做、錯了再補?

    📖 原書 Figure 7Try phase;粗紅線=transaction 持有鎖(依原書內容重繪)

    📖 原書 TC/C 是一種補償交易(compensating transaction),兩個步驟:

    • 第一階段:coordinator 請所有資料庫為交易保留資源
    • 第二階段:全部回「是」→ 請大家 Confirm(Try-Confirm);任何一個回「否」→ 請大家 Cancel(Try-Cancel)

    重點:2PC 的兩個階段包在同一個交易裡;TC/C 的每個階段都是獨立的交易。

    📖 Table 2 TC/C example:A 轉 $1 給 C
    PhaseAC
    1TryBalance change: −$1Do nothing
    2ConfirmDo nothingBalance change: +$1
    CancelBalance change: +$1Do nothing

    📖 原書 Wallet service 是 coordinator。開始時 A = $1、C = $0。Try 階段送兩個指令:對 A 所在的 DB 開一個本地交易扣 $1;對 C 所在的 DB 送 NOP(no operation),DB 對 NOP 什麼都不做、永遠回成功。

    原書 Step 2 · TC/CSecond phase · Figure 8–9

    第二階段:Confirm 把錢加到 C;Cancel 開一個新交易把錢加回 A

    這一步要解決的問題Try 做完之後:成功怎麼收尾?失敗怎麼補回去?

    📖 原書 Figure 8Confirm phase(原圖 C 的鎖標成 unlock A,應為 unlock C;依原書內容重繪)

    📖 原書 Confirm(Figure 8)

    兩個資料庫都回「是」,進入 Confirm。A 的餘額已在第一階段更新,wallet service 不用再改它;C 還沒收到 $1,所以 Confirm 階段要把 $1 加到 C。

    📖 原書 Cancel(Figure 9)

    如果 Try 失敗呢?上面假設 C 的 NOP 永遠成功,實務上可能失敗,例如 C 是非法帳戶,監管機關規定它不得有資金進出。這時分散式交易必須取消、做清理。

    A 的餘額已經在 Try 的交易裡更新了,已完成的交易沒辦法取消。能做的是啟動另一個交易,反轉 Try 的效果:把 $1 加回 A。C 在 Try 階段沒有被更新,只需要送 NOP。

    🏠 媽媽先從哥哥那裡拿出 $1(已經拿了)。妹妹那邊 OK 就放進去;妹妹那邊不收,就再走回去放回哥哥的存錢筒。

    原書 Step 2 · TC/CComparison between 2PC and TC/C · Table 3

    2PC 是「做完還沒交」;TC/C 是「交了,錯了再補」

    這一步要解決的問題2PC 和 TC/C 到底差在哪?各自付出什麼代價?

    📖 原書 兩者很像,也有差異。2PC 的第二階段開始時,所有本地交易還沒完成(仍然上鎖);TC/C 的第二階段開始時,所有本地交易已經完成(已經解鎖)。換句話說,2PC 的第二階段是把未完成的交易做完(commit 或 abort);TC/C 的第二階段是在出錯時,用反向操作抵銷先前交易的結果。

    📖 Table 3 2PC vs TC/C
    First PhaseSecond Phase: successSecond Phase: fail
    2PCLocal transactions are not done yetCommit all local transactionsCancel all local transactions
    TC/CAll local transactions are completed, either committed or canceledExecute new local transactions if neededReverse the side effect of the already committed transaction, or called “undo”

    📖 原書 TC/C 的優缺點

    TC/C 又叫補償式分散交易,是高階方案,因為補償(undo)寫在商業邏輯裡。

    • 優點:與資料庫無關,只要資料庫支援交易就能用
    • 缺點:分散交易的細節與複雜性,全部要在應用層的商業邏輯裡自己處理

    動手比:同一筆轉帳,鎖住多久?

    示意模型:2PC 從 write 到 commit 都握著鎖(約 2 個來回);TC/C 每個本地交易只在自己那台 DB 執行時上鎖,和網路來回無關。

    原書 Step 2 · TC/CPhase status table · Figure 10

    Wallet service 做到一半重啟:把進度寫進 phase status table

    這一步要解決的問題媽媽(wallet service)做到一半昏倒,醒來怎麼知道做到哪?

    📖 原書 還沒回答的問題:wallet service 在 TC/C 中途重啟怎麼辦?重啟時先前的操作紀錄可能遺失,系統不知道怎麼恢復。解法很簡單:把 TC/C 的進度以階段狀態存在交易型資料庫裡,至少包含:

    • 分散交易的 ID 與內容
    • 每個資料庫 Try 階段的狀態:「not sent yet」「has been sent」「response received」
    • 第二階段的名稱:Confirm 或 Cancel,可由 Try 的結果算出
    • 第二階段的狀態
    • 一個亂序標記(out-of-order flag,第 24 頁說明)

    📖 原書 放在哪裡?通常放在扣款錢包帳戶所在的資料庫。

    📖 原書 Figure 10Phase status table(依原書內容重繪)

    動手試:TC/C 走到一半,wallet service 重啟

    原書 Step 2 · TC/CUnbalanced state · Figure 11

    Try 結束時,$1 不見了一下下

    這一步要解決的問題Try 和 Confirm 之間,那 $1 在哪裡?

    📖 原書 Figure 11Unbalanced state(依原書內容重繪)
    $1A + C

    📖 原書 一切順利的話,Try 結束時 A 扣了 $1、C 沒變。A 和 C 的總和是 $0,比 TC/C 開始時少了。這違反會計的基本規則:交易後總和應該不變。

    📖 原書 好消息是 TC/C 仍然維持交易保證。TC/C 由多個獨立的本地交易組成,由應用程式驅動,所以應用程式看得到這些本地交易之間的中間結果。相對地,資料庫交易或 2PC 由資料庫維護,高階的應用程式看不到中間結果。

    📖 原書 分散交易執行過程中總會有資料不一致。這些不一致可能對我們透明,因為資料庫這類較低層的系統已經修好了;如果沒有,我們就得自己處理(例如 TC/C)。

    🏠 媽媽手上拿著 $1 走在走廊上:兩個存錢筒加起來少了 $1,但錢在媽媽手上。這時有人來數錢,就會數錯。

    原書 Step 2 · TC/CValid operation orders · Table 4

    Try 階段要先扣,不能先加

    這一步要解決的問題Try 階段要先扣還是先加?順序選錯會怎樣?

    📖 Table 4 Try phase choices
    Try phase choicesAccount AAccount C
    Choice 1−$1NOP
    Choice 2NOP+$1
    Choice 3−$1+$1

    你猜猜看:A 轉 $1 給 C,Try 階段選哪一種最安全?

    📖 原書 三種看起來都合理,但有些無效:

    • Choice 2:C 的 Try 成功、A 的 Try 失敗(NOP),要進 Cancel。但在這之間,別人可能已經把 C 的 $1 轉走了。等 wallet service 想從 C 扣回 $1,發現沒錢了,違反分散式交易的保證
    • Choice 3:同時扣 A、加 C,會引入很多複雜情況。例如 C 已經加了 $1,A 卻扣款失敗,這該怎麼處理?

    所以 Choice 2、3 有缺陷,只有 Choice 1 有效。

    動手試:選一種 Try,再讓 A 扣款失敗

    原書 Step 2 · TC/COut-of-order execution · Figure 12

    Cancel 比 Try 先到:沒有東西可以取消

    這一步要解決的問題網路慢,「取消」比「做」先到,怎麼辦?

    📖 原書 Figure 12Out-of-order execution(依原書內容重繪)

    📖 原書 TC/C 的一個副作用是亂序執行。沿用 A 轉 $1 給 C 的例子:Try 階段對 A 的操作失敗,回報給 wallet service,wallet service 進入 Cancel 階段,對 A 和 C 都送出 Cancel。

    📖 原書 假設 C 所在的資料庫網路有問題,先收到 Cancel、後收到 Try。這時沒有任何東西可以取消。

    📖 原書 解法:允許「沒收到 Try 就 Cancel」

    • 亂序的 Cancel 在資料庫裡留下一個標記:已經看到 Cancel,但還沒看到 Try
    • Try 一律先檢查有沒有這個標記,有的話就回傳失敗

    這就是 phase status table 要有亂序標記的原因。

    🏠 媽媽傳了「取消」的簡訊給妹妹,又傳了「我要放錢給你」,結果妹妹先收到取消。妹妹在門上貼一張紙條:「這筆已經取消了,之後再收到請拒絕。」

    延伸基礎第 7 階 · Saga懂的人可以跳過

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    照清單一步一步做;哪一步出錯,就倒著一步一步補

    ① 先想像

    媽媽有一張清單:① 從哥哥拿 $1 ② 放進妹妹 ③ 記進家庭帳本。照順序做,一步做完才做下一步;出錯就倒回去,把做過的每一步反過來做。

    你猜猜看:清單有 3 步,每一步都要事先準備好「反向動作」。總共要準備幾個動作?

    ③ 這叫做 Saga、orchestration

    Saga:一串依序做、各自完成的小 transaction,失敗就倒著補償。orchestration:由一個人(媽媽)照清單指揮大家。另見 22 章(機票 + 飯店)。

    ④ 跟這章的關係

    原書 Figure 13(第 26 頁)。和 TC/C 的差別:Saga 一次只做一步;TC/C 可以同時問兩邊。

    ② 動手玩:選一步讓它出錯

    按「執行」。

    原書 Step 2 · 高階方案Saga · Linear order execution · Figure 13

    Saga:一步一步往前做,失敗就一步一步往回補

    這一步要解決的問題另一種補償做法:排好順序,一步一步來。

    📖 原書 Figure 13Saga workflow(依原書內容重繪)

    📖 原書 另一個流行的分散式交易方案是 Saga,原書說它是微服務架構裡的事實標準(microservice:把系統拆成很多各管各的小服務,22 章)。概念很簡單:

    • 所有操作依序排好,每個操作都是自己資料庫上的獨立交易
    • 從第一個執行到最後一個,一個做完觸發下一個
    • 某個操作失敗,整個流程從目前的操作反向回滾到第一個,用補償交易。所以 n 個操作要準備 2n 個:n 個正常、n 個補償

    📖 原書 Figure 13:最上面的水平線是正常的執行順序,兩條垂直線是出錯時該做的事。出錯時轉帳被回滾,client 收到錯誤訊息。和「有效的操作順序」一樣,扣款要放在加款之前。

    🏠 媽媽依序做:先從哥哥那拿、再放到妹妹那。放的時候出事,就倒著做:從妹妹那拿回、放回哥哥那。

    原書 Step 2 · SagaChoreography vs orchestration · Table 5

    誰來指揮?各自聽事件,還是一個 coordinator 說了算

    這一步要解決的問題誰來指揮這一串步驟?TC/C 和 Saga 該選哪一個?

    Choreography

    微服務架構裡,參與 Saga 的所有服務訂閱彼此的事件來完成工作,完全去中心化。挑戰:服務之間完全非同步,每個服務都要維護內部狀態機,才知道別人發出事件時該怎麼辦;服務一多就很難管理。

    Orchestration

    一個 coordinator 指示所有服務照正確順序做事。能好好處理複雜性,所以通常是數位錢包系統的首選。

    動手看:誰知道整件事的進度?

    📖 Table 5 TC/C vs Saga
    TC/CSaga
    Compensating actionIn Cancel phaseIn rollback phase
    Central coordinationYesYes (orchestration mode)
    Operation execution orderanylinear
    Parallel execution possibilityYesNo (linear execution)
    Could see the partial inconsistent statusYesYes
    Application or database logicApplicationApplication

    📖 原書 用哪一個?看延遲需求:Saga 必須線性執行,TC/C 可以平行。沒有延遲需求、或服務很少(像這個轉帳例子),兩個都行;想跟上微服務的潮流就選 Saga。對延遲敏感、服務/操作很多,TC/C 可能較好。

    應徵者:為了讓轉帳有交易性,用關聯式資料庫取代 Redis,用 TC/C 或 Saga 實作分散式交易。面試官:很好!但有些情況不適用:使用者可能在應用層輸入錯誤的操作,導致金額不對。需要能追蹤問題根源、稽核所有帳戶操作,怎麼做?

    到這裡你已經會了小結 2 / 5

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    到這裡你已經會了:兩個房間一起改的三種做法

    下一階要解決的問題

    面試官又問:使用者打錯、程式有 bug,錢算錯了,怎麼追到是哪一筆、哪一天?

    延伸基礎第 8 階 · event sourcing懂的人可以跳過

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    帳本只記每一筆,不改餘額

    ① 先想像

    不在存錢筒外面貼「現在有 $5」,而是在一本流水帳上,每次進出寫一行:「媽媽給哥哥 +$2」「哥哥買糖 −$4」。寫過的行不擦掉,只往後加;想知道現在多少,就從頭加起來。

    你猜猜看:哥哥的流水帳是 +5、−1、+3、−2。哥哥現在有多少?

    ③ 這叫做 event、event sourcing

    event:一行「已經發生的事」,用過去式寫。event sourcing:只存 event,餘額用從頭加總(重播)算出來。

    ④ 跟這章的關係

    原書的設計 ③(第 31 頁)。Triton 對「餘額用加總算」有話要說(第 52 頁)。

    ② 動手玩:改數字 vs 記流水帳

    延伸基礎第 9 階 · reproducibility懂的人可以跳過

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    同一本流水帳,誰來重算都要得到一樣的數字

    ① 先想像

    月底發現少了 $3。拿流水帳從第一行重算,算到哪一行開始對不上,就知道錯在哪一筆。前提是每一行都寫死了:不能寫「看心情給」。

    你猜猜看:有一行寫的是「哥哥 +(擲一次骰子的點數)」。爸爸和奶奶各自重算,結果會一樣嗎?

    ③ 這叫做 reproducibility、deterministic

    reproducibility(可重現性):從頭重播,能重建任何時間點的狀態。deterministic(確定性):同樣的輸入,永遠得到同樣的結果。

    ④ 跟這章的關係

    面試官的需求(第 6 頁);原書 Figure 18 重播歷史(第 34 頁)。

    ② 動手玩:重播到第幾行

    原書 Step 2 · 設計 ③Event sourcing · Background · Definition

    審計員的三個問題,和 event sourcing 的四個名詞

    這一步要解決的問題面試官要「追得到錯在哪一筆」:帳要怎麼記?

    📖 原書 外部審計員可能會問

    1. 任意時間點的帳戶餘額是多少?
    2. 怎麼確定歷史和目前的餘額是正確的?
    3. 程式改版之後,怎麼證明系統邏輯仍然正確?

    系統性回答這些問題的設計理念是 event sourcing,源自 Domain-Driven Design(DDD)(一套照業務來切程式的設計方法)。

    文組翻譯

    不在存錢筒上寫「現在有多少」,而是在一本流水帳上寫每一筆進出。想知道任何一天有多少,就從第一頁加到那一天。

    Command 指令

    來自外部世界的預期動作,例如「把 $1 從 A 轉給 C」。event sourcing 裡順序非常重要,所以指令通常放進 FIFO(先進先出)佇列。

    Event 事件

    指令是意圖不是事實(可能無效,例如轉完會變負數)。驗證通過的指令必須執行,結果就是事件,用過去式:「已從 A 轉 $1 給 C」。事件必須是確定性的;一個指令可以產生 0 到多個事件;事件的產生可以有隨機性或外部 I/O。事件也放 FIFO 佇列。

    State 狀態

    套用事件後會改變的東西。錢包的狀態是所有帳戶的餘額,用 map 表示,通常存在 key-value 資料庫;關聯式資料庫也可以看成 KV:key 是 primary key,value 是那一列。

    State machine 狀態機

    驅動整個過程:① 驗證指令、產生事件 ② 套用事件、更新狀態。必須是確定性的:不能透過 I/O 讀外部隨機資料、不能用亂數;同一個事件套用到同一個狀態,結果永遠相同。

    原書 Step 2 · Event sourcingFigure 14–15

    靜態看:兩個狀態機;動態看:指令、事件、狀態三條線

    這一步要解決的問題指令、事件、狀態三樣東西,怎麼一起運作?

    📖 原書 Figure 14Static view of event sourcing(依原書內容重繪)

    📖 原書 狀態機把指令轉成事件、再套用事件。因為它有兩個主要功能,通常畫成兩個狀態機:一個驗證指令、一個套用事件。

    📖 原書 Figure 15Dynamic view of event sourcing(依原書內容重繪)

    📖 原書 加上時間維度:系統持續收到指令,一個接一個處理。每個指令 Validate 成事件,事件 Apply 成新的狀態。

    原書 Step 2 · Event sourcingWallet service example · Figure 16–17

    錢包版:Kafka 當指令佇列,狀態機五個步驟

    這一步要解決的問題放到錢包上:一筆轉帳指令,會變成哪些事件?

    📖 原書 Figure 17How state machine works(依原書內容重繪)

    📖 原書 對錢包服務來說,指令就是轉帳請求,放進 FIFO 佇列,熱門選擇是 Kafka(一種排隊系統,19 章;Figure 16)。假設狀態(餘額)存在關聯式資料庫。狀態機照 FIFO 順序一個個檢查指令:餘額夠,就為每個帳戶各產生一個事件。指令「A->$1->C」產生「A:-$1」和「C:+$1」兩個事件。

    1. 從指令佇列讀取指令
    2. 從資料庫讀取餘額狀態
    3. 驗證指令;有效的話,為兩個帳戶各產生一個事件
    4. 讀取下一個事件
    5. 更新資料庫裡的餘額,套用事件

    原書 Step 2 · Event sourcingReproducibility · Figure 18

    可重現性:事件不可變、狀態機確定,所以每次重播都一樣

    這一步要解決的問題有了流水帳,審計員的三個問題怎麼答?

    📖 原書 Figure 18Reproduce states;紅字是上一組事件改動的帳戶(依原書內容重繪)

    📖 原書 event sourcing 相較其他架構最重要的優勢就是可重現性。前面的分散式交易方案裡,wallet service 把更新後的餘額存進資料庫,很難知道餘額為什麼變了,而且更新時歷史餘額就遺失了。event sourcing 裡,所有變更先以不可變的歷史保存,資料庫只是某個時間點餘額的更新後視圖。

    📖 原書 回答審計員的三個問題

    1. 從頭重播事件,停在想知道的時間點
    2. 從事件列表重新計算,驗證餘額正確
    3. 對同一串事件跑不同版本的程式,比對結果是否相同

    📖 原書 因為具備審計能力,event sourcing 常被選為錢包服務的事實標準。

    延伸基礎第 10 階 · CQRS懂的人可以跳過

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    寫帳的只有媽媽一個,查帳的可以有很多個,只是會晚一點

    ① 先想像

    流水帳只有媽媽能寫。爸爸、奶奶各自抄一份,整理成自己想看的樣子:爸爸看「每人現在有多少」,奶奶看「這個月花了多少」。他們抄得比媽媽寫的慢一點。

    你猜猜看:媽媽剛寫下「哥哥 −$1」,1 秒後哥哥去問爸爸。爸爸要 2 秒才抄到。哥哥聽到的是?

    ③ 這叫做 CQRS、eventual consistency

    CQRS:寫的那一邊(command)和查的那一邊(query)分開。eventual consistency:查的那邊晚一點,但最後會趕上(06 章)。

    ④ 跟這章的關係

    原書 Figure 19(第 36 頁)。「剛轉完帳查不到」這個問題,原書最後用 push 解(第 44 頁)。

    ② 動手玩:一本寫、兩本查

    原書 Step 2 · Event sourcingCQRS · Figure 19

    CQRS:不發布狀態,發布事件,讓外面自己蓋想要的視圖

    這一步要解決的問題只有寫的那一邊,client 要怎麼查餘額?

    📖 原書 Figure 19CQRS architecture(依原書內容重繪)

    📖 原書 到目前為止錢包能轉帳了,但 client 還不知道餘額是多少。要有方法發布狀態給 event sourcing 框架外的 client。直覺做法是建一個資料庫唯讀副本分享出去;event sourcing 的答法不一樣:不發布狀態,而是發布所有事件,外面自己重建任何想要的狀態。這個設計理念叫 CQRS。

    • 一個狀態機負責狀態的寫入,但可以有多個唯讀狀態機建構不同的視圖供查詢
    • 例如一個存餘額給 client 查;另一個建構特定時間區間的狀態,用來調查重複扣款;這些狀態就是核對財務紀錄的稽核軌跡
    • 唯讀狀態機會有延遲,但最終會趕上:最終一致性

    應徵者:所有有效的業務紀錄都在不可變的事件佇列裡,可以驗證正確性。面試官:但這個架構一次只處理一個事件,還要跟多個外部系統溝通。能更快嗎?

    原書 Step 3High-performance event sourcing · Figure 20–21

    不走網路:指令、事件、狀態都存本地檔案,用 mmap

    這一步要解決的問題每處理一筆都要走網路去 Kafka 和資料庫,太慢:能不能全部放在本機?

    📖 原書 Figure 20File-based command and event storage(依原書內容重繪)

    📖 原書 先前用 Kafka 存指令與事件、資料庫存狀態。優化:

    • 指令與事件存本地磁碟,不走遠端的 Kafka,省掉網路傳輸。事件列表是 append-only:順序寫入通常非常快,連傳統硬碟都行,因為作業系統對順序讀寫做了大量優化。原書引 ACM Queue 的文章:某些情況下,順序磁碟存取甚至比隨機記憶體存取還快
    • 把最近的指令與事件快取在記憶體,省下從本地磁碟重新載入的時間
    • 實作:mmap(把檔案當記憶體用)把磁碟檔案映射成記憶體陣列,同時寫入本地磁碟、快取最近的內容;append-only 的檔案幾乎保證全在記憶體裡

    📖 原書 狀態也一樣:資料庫通常在另一台伺服器、只能透過網路存取,改存本地。可用 SQLite(本地檔案型關聯式資料庫)或 RocksDB(本地檔案型 KV)。原書選 RocksDB:它用 LSM tree(先寫記憶體、滿了整批寫檔,06 章),對寫入最佳化;最近的資料會被快取以提升讀取效能。

    延伸基礎第 11 階 · snapshot懂的人可以跳過

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    每個月底抄一次結餘,查帳不用從第一天加起

    ① 先想像

    流水帳寫了三年,查一個舊日子的餘額要從第一行加好幾萬行。如果每個月底在帳本上抄一行「月底結餘」,就只要從最近的那一行往後加。

    你猜猜看:每天 10 行、已經寫了 300 天,每 30 天抄一次結餘。查第 295 天的餘額,最多要加幾行?

    ③ 這叫做 snapshot

    snapshot:某個時間點、整份狀態的快照(月底結餘)。之後要查,只要「快照 + 後面的流水帳」。

    ④ 跟這章的關係

    原書 Figure 22 每天 00:00 拍一次(第 39 頁);Triton 的 081 也一樣,只是放在資料庫的一張表(第 60 頁)。

    ② 動手玩:結餘抄在哪一行後面

    藍色=要一行一行加的;灰色=已經包含在結餘(📌)裡。

    原書 Step 3Snapshot · Figure 22

    Snapshot:定期把狀態存成檔,重播不用從第一天開始

    這一步要解決的問題流水帳越來越長,重算越來越慢,怎麼辦?

    📖 原書 Figure 22Snapshot(依原書內容重繪)

    動手試:查第 N 天的餘額要重播多少事件?

    📖 原書 一切都檔案化之後,來加速可重現性。原本狀態機每次都要從頭處理事件;可以定期暫停狀態機,把目前的狀態存成檔案,這叫 snapshot。

    • Snapshot 是歷史狀態的不可變視圖。存好之後,狀態機不必從頭開始:讀 snapshot、確認停在哪裡,從那裡繼續
    • 財務團隊常要求在 00:00 拍 snapshot,才能驗證當天所有交易。原本 CQRS 要讓唯讀狀態機從頭讀到指定時間;有 snapshot 之後只要載入一個 snapshot
    • Snapshot 是一個巨大的二進位檔,常見做法是放在物件儲存(專門放大檔案的倉庫),例如 HDFS

    📖 原書 一切都檔案化後,系統能用滿電腦硬體的最大 I/O 吞吐量。面試官:本地檔案比遠端 Kafka 和資料庫快。但資料在本地磁碟,伺服器變成 stateful,而且是單點故障。怎麼提升可靠性?

    到這裡你已經會了小結 3 / 5

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    到這裡你已經會了:只記流水帳的錢包

    下一階要解決的問題

    為了快,原書把流水帳放在單一台電腦的本機檔案裡。這台電腦壞了怎麼辦?

    延伸基礎第 12 階 · Raft懂的人可以跳過

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    流水帳抄三份:過半數抄好,這一行才算數

    ① 先想像

    流水帳只有一本,燒掉就沒了。請小明、小華、小美三位一起抄:班長寫一行就唸給另外兩位聽,至少兩位(含班長)抄好,這一行才算數。班長請假,就從在場的人選一位新班長。

    你猜猜看:5 位一起抄,最多可以幾位請假,帳本還能繼續寫?

    ③ 這叫做 replication、Raft

    replication:同一份資料抄到好幾台(01 章、19 章)。Raft:一套「選班長、過半數抄好才算數」的規則。

    ④ 跟這章的關係

    原書用 Raft 複製事件列表(第 42–43 頁)。Triton 的材料沒談 Raft。

    ② 動手玩:點名字讓人請假

    原書 Step 3Reliability analysis · Consensus · Figure 23

    四種資料裡,只有「事件」需要高可靠性;用 Raft 複製它

    這一步要解決的問題資料都在本機,本機壞了怎麼辦?哪些資料一定不能掉?

    📖 原書 節點做的事只有兩個概念:資料與計算。只要資料是持久的,在另一個節點跑同樣的程式就能恢復計算結果。所以系統的可靠性主要是資料的可靠性。系統裡有四種資料:

    資料需要高可靠性嗎?原書的理由
    File-based state不用:重播事件列表就能重新產生
    State snapshot不用:同上
    File-based command不夠:事件的產生不保證確定性(亂數、外部 I/O),指令無法保證事件可重現
    File-based event要:事件是改變狀態的歷史事實、不可變、可重建狀態。唯一需要高可靠性的資料

    📖 原書 要在多個節點間複製事件列表,並保證:不遺失資料、各節點日誌裡的相對順序一致。基於共識的複製很適合,例如 Raft:只要超過半數節點在線,它們的 append-only 列表就有相同資料。

    📖 原書 Figure 23Raft:5 個節點,3 個 Up、2 個 Down(依原書內容重繪;點節點可以切換)

    📖 原書 Raft 的三種角色

    Leader、Candidate、Follower。叢集最多只有一個 leader,其他是 follower。Leader 接收外部指令,並可靠地把資料複製到叢集的節點。3 個節點能容忍 1 個故障;5 個能容忍 2 個。

    原書 Step 3Reliable solution · Figure 24

    三個 event sourcing 節點組成一個 Raft group

    這一步要解決的問題三台機器組成一組,壞一台還能繼續嗎?

    📖 原書 Figure 24Raft node group(依原書內容重繪)

    📖 原書 有了複製,檔案化的 event sourcing 架構就沒有單點故障。設 3 個 event sourcing 節點,用 Raft 同步事件列表:

    • Leader 接收外部使用者的指令,轉成事件,附加到本地事件列表;Raft 把新事件複製到 follower
    • 所有節點(包括 follower)都處理事件列表、更新狀態。Raft 保證事件列表相同,event sourcing 保證事件列表相同則狀態相同

    📖 原書 節點當機怎麼辦

    • Leader 當機:Raft 自動從健康節點選出新 leader,由它接收指令,叢集持續服務。若在指令轉成事件之前當機,client 會透過逾時或錯誤回應發現,要把同一個指令重送給新 leader
    • Follower 當機:比較好處理。送給它的請求會失敗,Raft 無限重試,直到它重啟或被新節點取代

    面試官:系統更可靠、更容錯了。但要處理 100 萬 TPS,一台伺服器不夠。怎麼讓系統更可擴展?

    原書 Step 3Distributed event sourcing · Pull vs push · Figure 25–27

    轉完帳想馬上知道結果:輪詢、加反向代理、改成推送

    這一步要解決的問題轉完帳要馬上知道結果;一組機器不夠時,還要分片。

    📖 原書 Figure 25Periodical pulling(依原書內容重繪)

    📖 原書 可靠的高效能 event sourcing 還有兩個限制:

    1. 希望錢包更新後立刻收到結果。但 CQRS 的請求/回應可能較慢:client 不知道錢包何時更新,只能定期輪詢
    2. 單一 Raft group 容量有限,到一定規模就要分片資料、實作分散式交易
    • Pull(Figure 25):外部使用者定期從唯讀狀態機輪詢執行狀態。不即時;輪詢太頻繁還可能讓錢包服務過載
    • Reverse proxy(Figure 26;替使用者跑腿的中間人):使用者把指令送給反向代理,由它轉給 event sourcing 節點並定期輪詢狀態。client 邏輯簡化了,但通訊仍非即時
    • Push(Figure 27):修改唯讀狀態機:收到事件就立刻把執行狀態推回反向代理,使用者感覺到即時回應

    原書 Step 3Distributed transaction · Figure 28

    最終設計:每個分片一個 Raft group,跨分片再用 TC/C 或 Saga

    這一步要解決的問題分片之後,A 和 C 在不同的分片上,轉帳怎麼做?

    📖 原書 Figure 28Final design(依原書內容重繪)

    📖 原書 一旦每個 event sourcing 節點群組都對外同步執行(反向代理 + push),就可以重用前面的分散式交易方案,例如 TC/C 或 Saga。

    📖 原書 假設用 key 的 hash 除以 2 來分割資料:Partition 1 放帳戶 A,Partition 2 放帳戶 C。每個分區是一個 Raft node group(一個 leader、兩個 follower)。TCC/Saga Coordinator 送指令(紅色)、收回應(藍色),並維護 Phase Status Table;Reverse Proxy 接收各分區即時推回的狀態(淺藍色)。

    繞一圈回到原點

    第 14 頁的問題是「兩個帳戶在兩台機器上」。最終設計裡,兩個帳戶還是在兩個分區上,所以還是需要 TC/C 或 Saga,只是每個分區從一台資料庫變成一個 Raft group。

    原書 Step 3Final design in a numbered sequence · Figure 29

    用 Saga 走一次成功路徑:15 個步驟

    這一步要解決的問題一筆成功的跨分片轉帳,實際走了哪些步驟?

    📖 原書 Figure 29Final design in a numbered sequence(依原書內容重繪)
    1. 使用者 A 送一個分散式交易給 Saga coordinator:兩個操作 A−$1、C+$1
    2. coordinator 在 phase status table 建一筆紀錄,追蹤交易狀態
    3. coordinator 檢查操作順序,決定先處理 A−$1,把它當指令送到放帳戶 A 的 Partition 1
    4. Partition 1 的 Raft leader 收到指令、存進指令列表、驗證;有效就轉成事件,用 Raft 同步各節點;同步完成後執行事件(A 扣 $1)
    5. 事件同步完成後,Partition 1 用 CQRS 把資料同步到 read path,重建狀態與執行狀態
    6. Partition 1 的 read path 把狀態推回給呼叫者,也就是 Saga coordinator
    7. coordinator 收到 Partition 1 的成功狀態
    8. coordinator 在 phase status table 記下 Partition 1 成功
    9. 第一個操作成功,coordinator 執行第二個:把 C+$1 當指令送到 Partition 2
    10. Partition 2 的 Raft leader 收到、存進指令列表;有效就轉成事件、Raft 同步,同步完成後執行(C 加 $1)
    11. Partition 2 用 CQRS 同步到 read path,重建狀態與執行狀態
    12. Partition 2 的 read path 把狀態推回 Saga coordinator
    13. coordinator 收到 Partition 2 的成功狀態
    14. coordinator 在 phase status table 記下 Partition 2 成功
    15. 所有操作成功,分散式交易完成,coordinator 回應呼叫者

    原書 Step 4Wrap up · Chapter summary

    原書的收尾:五個設計,一路演進

    這一步要解決的問題回頭看:五個設計,各解決了什麼、又製造了什麼?

    📖 原書 Chapter Summary本章心智圖(依原書內容重繪)
    1. 📖 設計一個每秒處理超過 100 萬筆付款指令的錢包服務;估算後需要數千個節點
    2. 第一個設計:類似 Redis 的 in-memory KV。問題:資料不具持久性
    3. 第二個設計:換成交易型資料庫;為了多節點,提出 2PC、TC/C、Saga。問題:不容易做資料稽核
    4. 接著引入 event sourcing:先用外部資料庫與佇列,效能不佳;改成在本地節點存指令、事件、狀態
    5. 單一節點是單點故障:用 Raft 把事件列表複製到多個節點
    6. 最後採用 CQRS,加上反向代理,把非同步的 event sourcing 框架變成對外同步;用 TC/C 或 Saga 協調多個節點群組間的指令

    原書到這裡結束(原書還說了一句:恭喜你走到這裡,給自己一個讚)。下一頁開始是 Triton 的觀點。

    到這裡你已經會了小結 4 / 5

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    到這裡你已經會了:原書的完整設計

    下一段:Triton 的觀點

    Triton 會從第 3 階開始質疑:為什麼兩個存錢筒一定要放在兩個房間?

    Triton 觀點總覽

    原書一路加元件;Triton 會先問:為什麼帳戶一定要在兩台機器上?

    原書這樣做會出什麼事?最後的設計(第 45 頁)裡,A 和 C 在不同分片時,還需要 TC/C 或 Saga 嗎?

    📖 原書的路線

    1. Redis 分片 → 不持久、不 atomic
    2. RDBMS 分片 + 2PC / TC/C / Saga → 不好稽核
    3. Event sourcing + Kafka → 慢
    4. 本地檔案 + mmap + RocksDB → 單點故障
    5. Raft group → 一組不夠 1M TPS
    6. CQRS + reverse proxy + 分片 + TC/C / Saga

    「你用event-sourcing,也是避不了這堆問題的」「大家沒到amazon這種級別流量都會用postgresql / mysql 是有其原因的」🗣️ Triton 本人說 100-二份data是存放在不同的machine上(2pc).md

    ① 錢不放 Redis,放 RDBMS

    「不能不見的data,我一定存到RDBMS」106 📝「如果跟錢有關的話,千萬不要用 redis」029 課堂筆記 → 第 50 頁

    ② 扣款是一句有條件的 UPDATE,照順序上鎖

    WHERE balance - delta >= 0 沒有 race,sum(delta) 有177;兩個帳戶依 ID 排序再改,否則 deadlock120 → 第 52–55 頁

    ③ 跨機器就躲不掉 2PC;event sourcing 也一樣

    「如果你說不用2pc的,你可以寫論文了」100;event-based 不是沒有鎖084 → 第 56–58 頁

    ④ 先 scale up;可重現性用流水帳 + 對帳

    20 core + 200GB RAM 絕大部份不用 clustering106;banker 加總為零、snapshot + sum(activity) = balance081 → 第 59–61 頁

    Triton 觀點029(課堂筆記)· 106 · 對照原書設計 ①

    「如果跟錢有關的話,千萬不要用 redis」

    原書這樣做會出什麼事?餘額放在 Redis(每 10,000 次寫入才落盤一次),半夜停電。早上會怎樣?

    「default presistis mode 是 10000 個 write 才會寫入 harddisk 中。 而且回傳 OK 時,也不是保證有到 disk 。這時候如果 power down 的話,會有些 data lose 的。 如果跟錢有關的話,千萬不要用 redis」📝 上課筆記 029-Redis.md(無署名的 Redis 課堂筆記,非 Triton 原文;006 是 Notion 版)

    「只有 relation db 能處理這種 multi state, multi record 的情況」「3台 redis redis1 存A資料 redis2 存B資料 A轉錢給B、 2 phase commit 代表你的 data 要 lock 在那邊。 你的 data 就沒有 avaiability。」📝 上課筆記 029(用字照原文)

    「主要還是一句:不能不見的data,我一定存到RDBMS」🗣️ Triton 本人說 106-喵 data.md

    動手試:Redis 上的轉帳,然後斷電

    🔭 套到原書

    原書自己的收尾也說設計 ① 的問題是「資料不具持久性」。但就算每次寫入都落盤,A 和 B 在不同的 Redis 節點上,斷電時可能 A 的扣款落盤了、B 的入帳沒有:這就是 029 筆記說的「只有 relation db 能處理這種 multi state, multi record 的情況」。

    📅 2026 補充 現在的 Redis 預設是 RDB 快照(save 3600 1 300 100 60 10000)、AOF 預設關閉;開 AOF 並設 appendfsync always 才是每次寫入都 fsync,代價是效能。筆記的「10000 個 write」對應的是其中一條快照規則。

    延伸基礎第 13 階 · race condition懂的人可以跳過

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    兩台 ATM 同時看到 $100,各吐出 $80

    ① 先想像

    哥哥和妹妹拿同一個帳戶的卡,在兩台 ATM 同時領錢。兩台都先看餘額「還有 $100,夠」,再各自扣 $80。

    你猜猜看:帳戶 $100,兩台都在對方扣款之前看了餘額。最後一共吐出多少現金?

    ③ 這叫做 race condition、atomic check-and-set

    race condition:兩人同時「先看、再寫」,有一人根據過期的數字做決定(22 章)。atomic check-and-set:「夠不夠」和「扣款」是同一個動作,中間不能插隊(22 章)。

    ④ 跟這章的關係

    Triton 177 用這個例子,比較「只記流水帳」和「一句有條件的 UPDATE」(下一頁)。

    ② 動手玩:兩台 ATM

    $100帳戶餘額$0吐出的現金

    Triton 觀點 · 動手玩177 · 對照原書的 event sourcing

    同一個人在兩台 ATM 同時提款:sum(delta) vs 一句 UPDATE

    原書這樣做會出什麼事?如果只記流水帳(user_activity),帳戶 $100,兩台 ATM 同時各領 $80,都先用加總確認「夠」。

    帳戶有 $100,兩台 ATM 各要提 $80。

    $100帳戶餘額$0吐出的現金

    「如果現在系統是用event sourcing來設計,現在系統沒有用戶的current balance 現在就只有user_activity這個table 如果現在系統要知道user current balance, 就要跑這樣子的SQL: select sum(delta) as current_balance from user_activity;」「如果現在有一個用戶,同時在2台ATM上提錢,2台機器在跑這個select-statement時都是正數 然後把提款記錄insert進去時,用戶balance可以立即跳進負值。 這就是race condition」🗣️ Triton 本人說 177-簡單的銀行存款取款系統.md

    update user_balance
    set balance = balance - delta
    where balance - delta >= 0

    「這是atomic-check-and-set手法。 如果用戶同時2台ATM來提款,其中一台ATM執行時會沒法滿足where-condition引發rollback的。(假設用戶的錢只夠提一次) 所以沒法有race condition。」🗣️ 177

    🔭 公平地說 原書沒有用 sum(delta) 驗證:它讓單一 state machine 依 FIFO 一個個驗證,所以不會 race(第三個按鈕)。代價是那條 FIFO 本身就是一把鎖,見第 57 頁。

    Triton 觀點177 · 109 / 158 · 083 · 089 · 對照原書 Figure 7

    原書的 Try 沒查餘額:把檢查寫進 WHERE,看 AffectedRow

    原書這樣做會出什麼事?Figure 7 的 Try 是 WHERE account='A'。A 只剩 $0 時,這句會?

    📖 原書 Figure 7

    UPDATE balance
    SET amount=amount-1
    WHERE account='A'

    檢查「餘額夠不夠」要在 wallet service 先讀再判斷:讀和寫之間別人可能先扣了。

    🔭 177 的寫法套進 Try

    UPDATE balance
    SET amount = amount - 1
    WHERE account = 'A'
      AND amount - 1 >= 0;
    -- 0 rows → Try 失敗

    「面對什麼「高並發」沒有什麼花招的 就單純把你的transaction縮短,讓你 row-lock的時間變短就好」「這樣子的atomic CAS,如果record中間有被別人改過了,其AffectedRow就不會是2」🗣️ Triton 本人說 109-喵 談atomic CAS (compare and swap).md(= 158)

    update tableX
    set columnA = (case when id = 1 then 200 else 100 end)
    where (id, columnA) in ((1, 100), (2, 200));
    if (@AffectedRow == 2) then commit transaction
    else rollback transaction and raise exception("data updated by others already")

    動手算:k 個請求同時從同一個錢包扣款

    示意模型:optimistic lock 每一輪只有一個人成功,其他人重讀重試;atomic CAS 每個請求只送一句,在 row lock 上排隊。

    「optimistic lock的適用場景是low collision frequency(通常也是low update frequency)的資料保護」🗣️ 083 「Optimistic lock is suitable if the conflict rate is very low」089 · Lessons learnt

    🗣️ 誠實的一句 109 對自己的 CAS swap 也說:「這方案有沒有潛在deadlock問題? 我不肯定」「但是,當你row-lock時間越短,觸發deadlock可能性就越低囉~~~」。要真正排除 deadlock,看下一頁。

    延伸基礎第 14 階 · deadlock懂的人可以跳過

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    媽媽握著哥哥的鑰匙等妹妹的,爸爸握著妹妹的等哥哥的

    ① 先想像

    要改存錢筒,先拿到它的鑰匙。媽媽要做「哥哥轉給妹妹」,爸爸同時要做「妹妹轉給哥哥」,兩人都要拿兩把鑰匙。

    你猜猜看:媽媽先拿到哥哥的鑰匙、爸爸先拿到妹妹的,兩人都在等另一把。會怎樣?

    ③ 這叫做 lock、deadlock

    lock:鑰匙,拿到的人才能改(01 章)。deadlock:兩人各握一把、互等對方,誰都動不了。

    ④ 跟這章的關係

    原書 2PC 一次鎖住 A 和 C(第 16 頁)。Triton 自己在 production 踩過(下一頁)。

    ② 動手玩:兩人先拿哪一把?

    媽媽先拿
    爸爸先拿
    —結果

    Triton 觀點 · 動手玩120(= 183)· 113

    Triton 自己在 production 引發的 deadlock:Go 的 map 不保證順序

    原書沒提醒的事:兩個「A 轉給 B」同時跑,各自用 for each 走過一個「不保證順序」的 map 來改兩個帳戶。會怎樣?

    0deadlock errors0成功

    「1 我們用的是golang,其map iterator(就是pseudo code中for each那一部份)是不保證順序的。」「3 所以重組案情後,其deadlock的2個Request分別是:…你會看到,這2個request都改動了一個用戶並且鎖住了,然後想改動對方已經鎖住了的用戶嘛……」🗣️ Triton 本人說 120-喵示範自己如何引發production deadlock.md(183 是同一篇加後記)

    「重點:然後再把這個array sort by userID,讓userID比較小的用戶首先改動。」「(某T的design flaw,成功讓公司主系統當掉了近15分鐘耶~)」「test case大部份都是single thread來執行,保護不了像我們這樣子在multithread環境發生的deadlock。」🗣️ 120

    🗣️ 「假設你在寫遊戲,現在用戶A可以把自己的分數轉帳給用戶B。你知道怎樣做,才不會發生因為當機而數據出錯嗎?」「(續上題)你知道有什麼情況下會發生deadlock嗎?你知道如何回避嗎?」113 · 喵的 backend 測驗第 3、4 題

    🔭 套到原書 原書 2PC 的 Figure 5 一次鎖住 A 和 C;同時有人做 C 轉 A,兩個 coordinator 也會互相等。轉帳只要一次鎖兩個帳戶,就要固定順序。

    Triton 觀點100 · 123 · 106 · 對照原書的 2PC / TC/C

    「如果你說不用2pc的,你可以寫論文了」:所以先別讓轉帳跨機器

    「如果你有二份data,例如: 商品X的現有存量,和用戶Y的account-balance 如果這二份data是存放在不同的machine上,而你是需要做到strong consistency的 (即是說:不能扣了錢但是沒給用戶商品) 那麼2pc(或是其變種)是不能避免的」🗣️ Triton 本人說 100

    「1 要改動2份資料 2 這2份資料不是放在同一台主機上 3 這2份資料,最終要一起被改動,或是一起沒被改動(例子:銀行轉帳,要麼成功轉帳,要麼什麼也沒發生,不能扣了錢後沒加錢) 如果你要同時滿足這3點,你肯定需要2pc的。」🗣️ 123-喵談 2pc.md

    🔭 對照原書 TC/C 就是 2PC 的變種

    123 的 Passkit + Stripe:先建立未收款的 Charge(Try)、把 stripeChargeId 存進 DB、再 capture(Confirm)。原書的 phase status table 就是那一欄 stripeChargeId:重啟時看它決定從哪一步重做。詳見 Payment 那一章。

    原書這樣做會出什麼事?分成 2,000 台,隨便挑兩個帳戶轉帳,要跨機器(需要分散式交易)的大約占多少?

    動手算:分成 N 片,多少轉帳要跨片?

    假設轉帳雙方是隨機的兩個帳戶:同片機率 1/N。

    「如果是小型系統,單純scale up便算了」「如果到了scale up盡頭又不想走Hbase那些noSQL 要RDBMS的clustering其中雷區冒險,我還不如走傳統的sharding路線」🗣️ 106

    🔭 公平地說 Triton 不是說永遠不分片:scale up 到盡頭,他也走 sharding,那時跨片的轉帳就照 100 和 123 做 2PC。差別在順序:原書從估算的第一頁就決定 2,000 個節點,所以幾乎每一筆轉帳都要分散式交易。

    Triton 觀點100 · 084 · 059 · 185 · 對照原書 Figure 15、28

    Event sourcing 不是沒有鎖:鎖搬到了 FIFO 上

    原書這樣做會出什麼事?狀態機照 FIFO 一個一個處理指令,只做 append。這樣是不是就沒有鎖、可以無限快?

    🗣️ Triton 本人說 Misconception on high performance

    • 「The event-based architecture has no LOCK」→「The is a LOCK on MQ FIFO channel to maintain data integrity」
    • 「Only APPEND is involved」→「Yes, but the bottleneck is the matching engine and database updater」「The matching operation is still in single thread」

    Conclusion:「Event-based architecture gives ultra-high performance」But「limited to specific use-case.」「Super complex」「Super hard to be truly robust」084-order matching-system design.pdf.md · 第 12、22 頁(用字照原文,含 “The is”)

    「有人在架構文章提到了event sourcing好棒棒,用了後就不怕爆流……」「不管你Application層長怎樣。你最終會受限的還是單一Record其在DB層的處理上限。」🗣️ 185-電商用 queue-.md

    🔭 用原書自己的圖來看

    原書說其實
    狀態機依 FIFO 一個個處理(Figure 15)這就是 084 的「LOCK on MQ FIFO channel」:每個分區一條 thread 排隊
    event sourcing 解決可重現性與效能跨分區的轉帳,最後還是用 Step 2 的 TC/C / Saga(Figure 28):100 的「避不了這堆問題」
    CQRS 唯讀狀態機「最終會趕上」059:「一般是 Eventual-consistency」;所以原書要再加 reverse proxy + push 把它變回同步
    Raft 讓事件列表可靠Triton 的材料沒談 Raft;084 只說這類架構「Super hard to be truly robust」

    數一數:一筆 $1 的轉帳經過什麼

    🗣️ 「一般是 Eventual-consistency」「系統 Current state = 從 Day 1 replay 所有的 event」「為了效能,一般會配上 CQRS」「簡單而言: materialized view」;實用例子只寫了「Stock Exchange」,下一行是「=.=」059 · 第 23–24 頁

    Triton 觀點 · 動手玩051 · 126 · 084 · 185

    熱門帳戶:分再多片,那一個錢包還是在一條 thread 上

    動手試:一個大商家的錢包收大部分的錢

    原書這樣做會出什麼事?分成 200 片、每片每秒 1 萬筆。5% 的轉帳都打到同一個外送平台的錢包,系統每秒最多幾筆?

    白話:hotspot=大家都擠向同一筆資料、同一台機器(05 章、04 章)。

    「如果你需要 Consistency,不管你是 RDBMS 還是 noSQL,一份資料只會存放在一個 master node內」「重點: hotspot是卡在 single thread效能,你沒法以加開機器來解決的」🗣️ Triton 本人說 051-concurrency.pdf.md · 第 17 頁

    「同一份的資料,如果你需要維持strong consistency,最終你的Write是沒法distributed,讓你的系統出現hotspot的。」🗣️ 126 · 041

    「For hot Item, such update will be the hotspot, no matter if you are using event sourcing in following stages.」🗣️ 084 · 第 20 頁

    🔭 套到原書 原書的 1M TPS 是「總量」,用 hash 平均分片。但錢包的流量不平均:電商平台、外送平台的商家錢包一秒收幾千筆。那個帳戶的所有指令都進同一個分區、同一個 state machine。

    Triton 觀點 · 動手玩106 · 116 · 099 · 084 · 對照原書估算

    先 scale up,再 batch:先把一台機器用滿

    「正常沒亂來的系統,在20core + 200GB RAM的暴力機器下,絕大部份都沒需要玩clustering」「除非你要面對C100K,何必自找麻煩做db clustering呢」「吐嘈一句:我遇過很多老闆都跟我說最終他的系統會concurrent 1M user 但是台灣WOW的最高在線人數才650K」🗣️ Triton 本人說 106

    「然後一堆很賺錢的商業系統(像銀行),其總資料庫連1TB都不到下。」「RDBMS去Read / Write一份資料時,是需要用上的Page lock / Row lock。然後其背後的lock manager,今天漸漸變成系統的bottleneck。」🗣️ 116-喵看 RDS.md

    🗣️ 「今天來說,pg能輕易100 TX / sec,連一台筆電也能做到。」「1000 TX / sec也不是什麼困難事。」099 「Instead of processing the incoming event one-by-one」「process events in BATCH」「MASSIVELY reduce IO latency」084 · 第 15 頁

    🔭 套到原書

    原書的目標「提升單一節點能處理的交易數」是對的,它的答案是本地檔案 + mmap;Triton 式的答案是大機器 + 把多筆轉帳合成一次落盤(084 的 batch)。1M TPS 這個需求本身,也值得先問一句:真的嗎?

    白話:scale up=換一台更大的機器,而不是加很多台(01 章)。

    原書這樣做會出什麼事?每次 commit 要等 1 ms 落盤。把 1,000 筆轉帳合成一次落盤(batch),一台每秒能做的會?

    動手算:Table 1 的「每節點 TPS」不是固定的

    Triton 觀點 · 動手玩081 · 對照原書的可重現性與 snapshot

    在 RDBMS 裡回答審計員的三個問題:流水帳、snapshot、banker

    原書說可重現性要靠 event sourcing。Triton 的 081:每筆交易同時改 user_balance 和 banker(銀行那一格)。所有人餘額加上 banker,應該等於?

    「begin tx update user_balance set balance += <coin_delta> where id = <user_id>; update banker set amount -= <coin_delta> where item = <遊戲貨幣>; end tx 這樣子,除非你用的RDBMS有bug/你的application有bug/你自己就是bug,否則系統中的user_balance和banker的加總應該是永遠都是零的。」🗣️ Triton 本人說 081-online game system….md

    「所以,系統中應該有user_balance_snapshot這個table,其存的是7年前用戶的balance。」「你要看單一用戶的帳戶是否有bug時: 就單純看看 user_balance_snapshot + sum(purchase_order) + sum(user_activity) 是否等於user_balance」🗣️ 081

    🔭 對照原書三個審計問題

    1. 任意時間點的餘額:snapshot + 那之前的 user_activity 加總(滑桿)
    2. 歷史與目前餘額正確:banker 加總為零(驗血)、逐人比對(MRI)
    3. 改版後邏輯仍正確:同一份 activity 跑新舊程式比加總。流水帳和餘額在同一個 TX 裡寫,所以兩者不會分歧

    Triton 式的錢包🔭 由 177 · 120 · 081 · 112 · 106 組合

    把前面幾頁組起來:一筆轉帳 = 一個短 transaction

    begin tx
      -- transaction_id 是 PK:同一筆重送,這裡就撞 unique key(API 的去重 ID)
      insert into wallet_transfer (transaction_id, from_account, to_account, amount) …;
      -- 兩個帳戶依 account_id 排序後才改(120)
      update account set balance = balance - :amount
       where account_id = :from and balance - :amount >= 0;   -- 177
      -- AffectedRow = 0 → 餘額不足 → rollback
      update account set balance = balance + :amount where account_id = :to;
      insert into account_activity (account_id, delta, transaction_id) values
        (:from, -:amount, :tx), (:to, :amount, :tx);              -- 081 的流水帳
    commit

    示意 SQL:「依 ID 排序」指兩句 UPDATE 的先後要照 account_id 大小排,上面為了好讀寫成 from 在前。儲值、提領才動 banker,轉帳只在使用者之間移動,加總本來就不變。

    原書五個需求 → Triton 式的回答

    餘額轉帳上面這一個 TX
    Transactions同一台 RDBMS 的 ACID;不跨機器就不需要 2PC(100)
    Reproducibilityaccount_activity + snapshot + banker 加總(081)
    1M TPS先懷疑、先 scale up 與 batch;到盡頭才 sharding,跨片的才做 2PC(106、084)
    99.99%Triton 的材料在這章沒有對應,不推論

    錢用 Decimal

    「如果是要面對financial data(就是任何跟錢有關的東西) 永遠用上十進制(Decimal)方式來儲存和計算,而不要用上floating point(binary)來儲存和計算 因為沒人想要收到99.9999999487這種金額的」🗣️ 112-喵提有關 算錢 的數值儲存.md

    原書第 8 頁說「了解風險的話,用 double 是合理的」;Triton 說「永遠」。

    Triton 觀點134 · 100 · 對照原書的 Saga

    原書:Saga 是微服務的事實標準;Triton:微服務是大公司的工具

    原書說想跟上微服務的潮流就選 Saga。Triton 覺得微服務主要在解決什麼問題?

    📖 原書

    「Saga 是在微服務架構中的事實標準」;選 TC/C 還是 Saga:「如果想跟隨微服務架構的趨勢,則選擇 Saga」;choreography 下「每個服務必須維護內部狀態機」。

    🗣️ Triton

    「如果系統不夠複雜公司不夠大,走microservice是單純玩弄自己的行為。」「microservice是大公司用來清楚切割責任範圍的好手段……」134-喵談 micro-serv.md

    「如果你在玩micro-service,不同service不共用database, 一旦你有2個resource是在不同service的 那麼你的micro-service API design就一定要造出像stripe / paypal這樣子的2pc架構 很容易出錯」🗣️ 100

    🗣️ 134 說的微服務兩個目的

    1. 讓一個 while(1) bug 的災情只局限在出事的 module,而不是全公司 global outage(FAANG 過萬個 dev 的規模)
    2. 不讓別的 team 亂改你的 code:「因為info-sec關係,不是本team的人沒有repository的access right耶(微笑)」

    🔭 套到原書

    這兩個目的都是組織問題,不是轉帳的技術需求。原書的轉帳例子裡,A 和 C 是同一種帳戶、同一個 wallet service;把它們放進不同的服務或分區,2n 個操作、補償交易、亂序標記、phase status table 全部是自己製造出來的工作。

    Triton 同意原書做對的地方

    這些地方,Triton 和原書站在同一邊

    ✅ 錢要用交易型資料庫

    原書設計 ② 用關聯式資料庫取代 Redis,原書的收尾也承認設計 ① 不持久。Triton:「不能不見的data,我一定存到RDBMS」106

    ✅ 先扣款、後加款

    Table 4 只有 Choice 1 有效、Saga 扣款在前。扣款那一步就是會失敗的那一步,177 的 where balance - delta >= 0 也是放在扣款上。🔭

    ✅ 進度要寫進交易型資料庫

    原書的 phase status table 放在 transactional DB 裡;123 的 2PC 也是先把 stripeChargeId 存進 DB,重啟時看它決定從哪一步重做。123

    ✅ Append 是順序 IO,很快

    原書說 append-only 的事件列表是順序寫入、非常快。Triton:「MQ工作是write append,是Seq. IO不是Random IO,效能可以很高的。」185「Random IO是Sequential IO的1 / 10效能也沒有。」104

    ✅ 用 push,不要輪詢

    原書最後從 pull 改成 push。Triton:「不好架構:B使用polling,每2秒就問A」「好架構:A建立websocket(或任何server push技術)」185;「不應該每數秒做一次Get request」113 第 6 題

    ✅ Snapshot 讓重算變便宜

    原書每天 00:00 拍 snapshot;081 的 user_balance_snapshot 是同一個想法,只是放在 RDBMS 的一張表裡、每年推前一次。081

    到這裡你已經會了小結 5 / 5

    1. TPS
    2. Redis
    3. sharding
    4. transaction
    5. 2PC
    6. TC/C
    7. Saga
    8. event sourcing
    9. reproducibility
    10. CQRS
    11. snapshot
    12. Raft
    13. race condition
    14. deadlock

    到這裡你已經會了:Triton 怎麼修

    14 階全部走完了

    下一頁用一句話收尾;再下一頁是名詞小卡,給大家課後複習。

    一句話記住

    錢放 RDBMS,扣款寫進 WHERE,兩個帳戶照順序鎖。
    帳戶不跨機器,就不需要 2PC;跨了,event sourcing 也救不了。

    原書對的地方

    • 錢要用交易型資料庫,Redis 不持久
    • TC/C 先扣後加、亂序標記、phase status table 持久化
    • 順序 IO、snapshot、push 取代輪詢
    • 可重現性是好需求:審計員的三個問題要答得出來

    Triton 會先問的地方

    • 1M TPS、2,000 台:先 scale up 了嗎?(106)
    • Try 的 UPDATE 沒有餘額條件(177)
    • 兩個帳戶一起鎖:順序固定了嗎?(120)
    • event sourcing 的 FIFO 就是鎖;跨分區還是要 TC/C(084、100)
    • Saga 是為了微服務,你的公司需要嗎?(134)

    Triton 式的做法

    • UPDATE … WHERE balance - delta >= 0,看 AffectedRow(177、109)
    • 依 account_id 排序再改(120)
    • 流水帳和餘額同一個 TX;banker 加總為零;snapshot(081)
    • Decimal(112);batch(084);大機器(106)

    本章名詞小卡課後複習用 · 每個名詞一句白話

    今天出現的名詞,一句話講完

    TPS每秒幾筆交易;一筆轉帳 = 扣款 + 入帳兩個操作
    node一台機器
    wallet service收到轉帳指令、去改兩個餘額的程式(媽媽)
    in-memory資料放在記憶體,快但斷電會不見
    Redis最常見的 in-memory 資料庫(白板)
    持久性寫進磁碟,停電後還在(抽屜裡的照片)
    sharding、partition資料照規則分給好幾台放;分出來的每一份
    hash 取餘數把帳號變成號碼再除以 N,決定放哪一台
    Zookeeper集中記「誰放在哪一台」的設定儲存
    stateless機器身上不記東西,誰來做都一樣
    transaction綁在一起的一組修改:全部生效或全部不算
    commit / rollback簽名生效/整組作廢

    給工程師的重點出處與標籤

    引述來源(materials/core)與原書對照

    Triton 本人的講義 / 文章

    • 177-簡單的銀行存款取款系統.md — 只有 user_activity、sum(delta) 的 phantom read 與 race;where balance - delta >= 0 的 atomic check-and-set
    • 100-二份data是存放在不同的machine上(2pc).md — 不同機器 + strong consistency 避不了 2PC、microservice 不共用 DB 就要做 Stripe / PayPal 式 2PC、「你可以寫論文了」、「你用event-sourcing,也是避不了這堆問題的」
    • 120-喵示範自己如何引發production deadlock.md(= 183,183 多了後記)— bulkUpdateUser、Go map iterator 不保證順序、sort by userID、主系統當掉近 15 分鐘、test case 抓不到 design flaw
    • 084-order matching-system design.pdf.md — 第 12 頁 no LOCK 的誤解、第 15 頁 batch、第 20 頁 hot item、第 22 頁結論
    • 081 banker 加總為零、user_balance_snapshot · 109(= 158)atomic CAS swap · 083 optimistic lock 只適合低衝突 · 089 Lessons learnt · 106(從「主要還是一句」起)RDBMS、scale up、sharding、1M user · 051 第 17 頁 hotspot · 126 / 041 strong consistency 的 write 沒法 distributed · 185 event sourcing 好棒棒、單一 record 上限、Seq. IO、polling · 059 第 23–24 頁 Event Sourcing · 116 銀行 <1TB、lock manager · 099 pg 100 / 1000 TX/s · 112 Decimal · 123 2PC 三條件 · 134 microservice · 113 第 3、4、6 題 · 104 Random vs Sequential IO

    📝 筆記:029(無署名 Redis 課堂筆記;「如果跟錢有關的話,千萬不要用 redis」、2PC 與 availability、multi record)。不引用:187–195(第三方與 AI 生成)、164 的未署名回覆(CQRS 售票)。PDF 轉出的引文只拿掉中文詞中間多出來的空格(051 的「還 是」「沒 法」),用字照原文(含 029 的「presistis」「avaiability」、084 的「The is」)。

    循序漸進(文組版)的頁面

    學習地圖(第 3 頁);延伸基礎 14 階:TPS(5)、Redis(9)、sharding(10)、transaction(12)、2PC(15)、TC/C(17)、Saga(25)、event sourcing(29)、reproducibility(30)、CQRS(35)、snapshot(38)、Raft(41)、race condition(51)、deadlock(54);小結(13、28、40、48、64);名詞小卡(66)。存錢筒是虛構情境、示意數字不是實測值;QPS、lock、hotspot、scale up 等連到別章的延伸基礎。

    原書對照

    Alex Xu & Sahn Lam, System Design Interview Vol.2 Ch.12。開場與 Figure 1–2(第 4 頁);Step 1 需求(6);估算與 Table 1(7);API(8);In-memory sharding 與 Figure 3(11);Database sharding 與 Figure 4(14);2PC 與 Figure 5–6(16);TC/C、Table 2、Figure 7(18);Confirm / Cancel 與 Figure 8–9(19);2PC vs TC/C 與 Table 3(20);Phase status table 與 Figure 10(21);Unbalanced state 與 Figure 11(22);Valid operation orders 與 Table 4(23);Out-of-order 與 Figure 12(24);Saga 與 Figure 13(26);Choreography / orchestration 與 Table 5(27);Event sourcing 定義(31);Figure 14–15(32);Wallet example 與 Figure 16–17(33);Reproducibility 與 Figure 18(34);CQRS 與 Figure 19(36);File-based 與 Figure 20–21(37);Snapshot 與 Figure 22(39);Reliability、Raft 與 Figure 23(42);Figure 24(43);Pull vs push 與 Figure 25–27(44);Final design 與 Figure 28(45);Figure 29(46);Wrap up 與心智圖(47)。30 張圖與 5 個表都依原書圖說、alt 與內文重繪。

    一個可以直接問自己的問題

    你的轉帳裡,兩個帳戶在不在同一台資料庫?如果在,你用了幾句 SQL、鎖的順序固定嗎?如果不在,你的 2PC 在每個步驟之間當機會怎樣?

    ← → 翻頁 · S 講者備註 · D 深/淺色
    1 / 1目錄