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 階。每一階只用前面講過的東西。
- 1TPS每秒幾筆轉帳
- 2Redis斷電就擦掉的白板
- 3sharding存錢筒分房間放
- 4transaction一起算或都不算
- 52PC先問兩邊可以嗎
- 6TC/C先做,錯了再補
- 7Saga排好順序倒著補
- 8event sourcing只記每一筆
- 9reproducibility誰重算都一樣
- 10CQRS寫一本、查另一本
- 11snapshot月底抄結餘
- 12Raft抄三份過半數
- 13race condition同時看、同時扣
- 14deadlock互相等鑰匙
第 1–4 階 · 一筆轉帳,兩個存錢筒
要回答:存錢筒放在兩個房間,為什麼就會出事?
第 5–7 階 · 兩個房間一起改
要回答:原書的 2PC、TC/C、Saga 差在哪?
第 8–11 階 · 只記流水帳
要回答:怎麼證明每一塊錢的來龍去脈?
第 12 階 · 流水帳不怕壞
要回答:一台壞了怎麼辦?原書最後長怎樣?
第 13–14 階 · Triton 的修法
要回答:為什麼一句 UPDATE 就夠,還要照順序鎖?
全程只用一個家:哥哥、妹妹的存錢筒(虛構)
一開始哥哥、妹妹各有 $5,加起來 $10;原書的例子是 A 轉 $1 給 C。每爬 3–4 階,有一頁「到這裡你已經會了」。
原書開場Figure 1–2
錢包能存錢、付款,也能直接轉給同平台的其他人
這一步要解決的問題錢包到底在做什麼?這一章只管其中哪一件事?
📖 原書 支付平台通常提供數位錢包:從銀行卡把錢存進錢包,線上購物時選擇用錢包裡的錢付款(Figure 1)。
📖 原書 花錢不是唯一功能。像 PayPal 這樣的平台,可以直接把錢轉到同一平台上其他人的錢包。比起銀行間轉帳,錢包之間的轉帳更快,而且通常不收額外手續費(Figure 2)。
這場面試的題目
設計一個支援跨錢包餘額轉帳的數位錢包後端。和上一章的差別:錢不離開平台,沒有外部 PSP,A 少多少、B 就多多少。
延伸基礎第 1 階 · TPS懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
媽媽每秒要轉 10 筆零用錢,要請幾位幫手?
① 先想像
媽媽每轉一筆零用錢,要動兩個存錢筒:從一個拿出來、放進另一個。一位幫手每秒只動得了固定幾次。
你猜猜看:每秒轉 10 筆,每秒要動幾次存錢筒?
每一筆都是「拿出」加「放入」兩個動作,10 × 2 = 20。原書的估算就是這樣把 100 萬變成 200 萬。
③ 這叫做 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 TPS | Node Number |
| 100 | 20,000 |
| 1,000 | 2,000 |
| 10,000 | 200 |
原書 Step 2API design
只有一支 API:POST /v1/wallet/balance_transfer
這一步要解決的問題外面要怎麼跟錢包說「請把 $1 從 A 轉給 C」?
📖 原書 Step 2 會談:API 設計,以及三種高階設計:① 簡單的 in-memory 方案、② 以資料庫為基礎的分散式交易方案、③ 具可重現性的 event sourcing 方案。API 採用 RESTful 慣例,這次面試只需要一支:
| API | Detail |
|---|---|
POST /v1/wallet/balance_transfer | Transfer balance from one wallet to another |
| 📖 原書 Request parameters | ||
|---|---|---|
| Field | Description | Type |
from_account | The debit account 借方帳戶 | string |
to_account | The credit account 貸方帳戶 | string |
amount | The amount of money 金額 | string |
currency | The currency type 貨幣類型 | string (ISO 4217) |
transaction_id | ID 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懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
冰箱上的白板寫得快,可是停電就擦掉了
① 先想像
媽媽把每個人的錢寫在冰箱的電子白板上,改起來很快。可是這塊白板一停電就清空,所以媽媽每寫 10 筆,就拍一張照片收進抽屜。
你猜猜看:每 10 筆拍一次照,寫到第 25 筆時停電。哪些紀錄不見了?
抽屜裡的照片停在第 20 筆。第 21–25 筆只寫在白板上,跟著停電一起消失。右邊試試看。
④ 跟這章的關係
原書第一個設計把餘額放在 Redis(第 11 頁)。Triton 那邊:跟錢有關千萬不要(第 50 頁)。
② 動手玩:白板 + 抽屜
延伸基礎第 3 階 · sharding懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
存錢筒太多,一個房間放不下:照編號分到不同房間
① 先想像
親戚的小孩一共 16 個存錢筒,一個房間放不下,就照編號分到幾個房間。媽媽轉帳時,兩個存錢筒常常不在同一間。
你猜猜看:分成 4 個房間,隨便挑兩個存錢筒轉帳,兩個剛好在同一間的機會大約是?
第一個在哪間都行,第二個要剛好落在同一間:4 間裡中 1 間。其他大約 3/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)上,分到很多台。哪裡會出錯?
📖 原書 錢包要維護每個帳戶的餘額,<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懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
同一本帳簿上的兩行:要嘛一起算,要嘛都不算
① 先想像
媽媽在帳簿上寫「哥哥 −$1」「妹妹 +$1」,最後簽名才算數。還沒簽名就停電,寫了的行全部作廢。
你猜猜看:寫完「哥哥 −$1」、還沒寫「妹妹 +$1」就停電。隔天帳簿怎麼算?
沒簽名的就全部作廢,不會只少一邊。所以加起來永遠是 $10。
③ 這叫做 transaction、commit
transaction:綁在一起的一組修改,要嘛全部生效、要嘛全部不算(rollback)。commit:簽名,讓這一組生效。另見 07 章、22 章。
④ 跟這章的關係
一台資料庫裡,一個 transaction 就保證了轉帳。可是兩個存錢筒在兩台機器上,一本帳簿管不到(第 14 頁)。
② 動手玩:照 ①②③ 寫,隨時停電
到這裡你已經會了小結 1 / 5
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
到這裡你已經會了:存錢筒放在兩個房間,為什麼會出事
- 一筆轉帳是兩個動作:拿出、放入。每秒幾筆叫 TPS;原書 100 萬 TPS 要 2,000 台。
- 餘額放在 Redis 這種記憶體白板上很快,但停電會不見。存錢筒太多就分房間放(sharding)。
- 同一本帳簿裡,transaction 讓兩行「一起算或都不算」。兩個房間各一本帳簿,就管不到了。
下一階要解決的問題
兩個房間各有一本帳簿,怎麼讓兩邊一起改?原書給了三個答案:2PC、TC/C、Saga。
原書 Step 2 · 設計 ②Distributed transactions · Database sharding · Figure 4
把 Redis 換成關聯式資料庫:每個節點都有 transaction 了,還不夠
這一步要解決的問題換成有 transaction 的資料庫,兩個房間的問題解決了嗎?
📖 原書 怎麼讓兩個不同儲存節點上的更新成為 atomic?第一步:把每個 Redis 節點換成具 transaction 能力的關聯式資料庫節點。這次 A、B、C 被分到三個關聯式資料庫。
📖 原書 只用交易型資料庫只能解決一部分問題:一個轉帳指令很可能要更新兩個不同資料庫裡的兩個帳戶,無法保證兩個更新在同一時間點執行。如果 wallet service 更新完第一個帳戶就重啟,怎麼確保第二個帳戶也會更新?
📖 原書 分散式交易的兩種做法
- 低階方案:靠資料庫本身,最常用的是 two-phase commit(2PC)
- 高階方案:在應用層的商業邏輯裡做,例如 TC/C 和 Saga
🏠 存錢筒換成「有鎖的保險箱」:每個保險箱自己開關都安全,但兩個保險箱還是在兩個房間。
延伸基礎第 5 階 · 2PC懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
兩個房間各一本帳簿:先問兩邊「可以嗎」,都說好才一起簽
① 先想像
媽媽先打電話問哥哥房間、再問妹妹房間:「可以嗎?」說可以的人就先按住存錢筒,不讓別人動。兩邊都說可以,媽媽才喊「簽」。
你猜猜看:兩邊都說「可以」、都按住了,媽媽卻突然昏倒。哥哥能自己放手嗎?
哥哥不知道妹妹那邊說了什麼,只有媽媽知道該「簽」還是「取消」。按著不放,別人就都不能動這個存錢筒。
③ 這叫做 2PC、coordinator
2PC(two-phase commit):第一階段問「準備好了嗎」(prepare),全部說好,第二階段才一起 commit。coordinator:打電話問的那個人,就是媽媽。
④ 跟這章的關係
原書的「低階方案」(第 16 頁)。22 章用婚禮講過同一件事:22 章第 39 頁。
② 動手玩:三種情況
原書 Step 2 · 低階方案Two-phase commit · Figure 5–6
2PC:先問大家「準備好了嗎」,全部說好才一起 commit
這一步要解決的問題兩台資料庫,怎麼做到「要嘛一起改,要嘛都不改」?
📖 原書 分散式系統裡,一個交易可能牽涉多個節點上的多個程序。2PC 顧名思義有兩個階段:
- Coordinator(這裡是 wallet service)照常對多個資料庫讀寫,資料庫 A 與 C 都被鎖住
- 應用程式要 commit 時,coordinator 請所有資料庫 prepare
- 第二階段,coordinator 收集回覆:全部回「是」→ 請大家 commit;任何一個回「否」→ 請大家 abort
📖 原書 為什麼叫「低階」?兩個問題
- prepare 階段需要修改資料庫交易才做得到,例如協調異質資料庫的 X/Open XA 標準(讓不同牌子的資料庫一起做 2PC)
- 效能差:等其他節點的訊息時,鎖可能被持有很久
- Coordinator 是單點故障(Figure 6):它在 prepare 後當機,資料庫回了 yes 卻沒人告訴它們要 commit 還是 abort
🏠 媽媽先把兩個存錢筒都按住,問「可以嗎」,兩邊都說可以才一起放手。媽媽昏倒的話,兩隻手都一直按著。
延伸基礎第 6 階 · TC/C懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
先真的把錢拿出來;妹妹那邊不收,再走回去放回去
① 先想像
媽媽不按住兩邊。她先從哥哥的存錢筒拿出 $1(這一步已經做完了)。妹妹那邊 OK 就放進去;不 OK,就走回去把 $1 放回哥哥那裡。
你猜猜看:$1 已經拿出來、還沒放進妹妹那邊時,有人來數兩個存錢筒,加起來是?
那 $1 在媽媽手上。中間這一下看得到「少了」,原書 Figure 11 就在講這件事。
③ 這叫做 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:第一階段先「做」,第二階段確認,或反向補回去
這一步要解決的問題不想一直按住兩邊(鎖),能不能先做、錯了再補?
📖 原書 TC/C 是一種補償交易(compensating transaction),兩個步驟:
- 第一階段:coordinator 請所有資料庫為交易保留資源
- 第二階段:全部回「是」→ 請大家 Confirm(Try-Confirm);任何一個回「否」→ 請大家 Cancel(Try-Cancel)
重點:2PC 的兩個階段包在同一個交易裡;TC/C 的每個階段都是獨立的交易。
| 📖 Table 2 TC/C example:A 轉 $1 給 C | |||
|---|---|---|---|
| Phase | A | C | |
| 1 | Try | Balance change: −$1 | Do nothing |
| 2 | Confirm | Do nothing | Balance change: +$1 |
| Cancel | Balance change: +$1 | Do 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 做完之後:成功怎麼收尾?失敗怎麼補回去?
📖 原書 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 Phase | Second Phase: success | Second Phase: fail | |
| 2PC | Local transactions are not done yet | Commit all local transactions | Cancel all local transactions |
| TC/C | All local transactions are completed, either committed or canceled | Execute new local transactions if needed | Reverse 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 頁說明)
📖 原書 放在哪裡?通常放在扣款錢包帳戶所在的資料庫。
動手試:TC/C 走到一半,wallet service 重啟
原書 Step 2 · TC/CUnbalanced state · Figure 11
Try 結束時,$1 不見了一下下
這一步要解決的問題Try 和 Confirm 之間,那 $1 在哪裡?
📖 原書 一切順利的話,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 choices | Account A | Account C |
| Choice 1 | −$1 | NOP |
| Choice 2 | NOP | +$1 |
| Choice 3 | −$1 | +$1 |
你猜猜看:A 轉 $1 給 C,Try 階段選哪一種最安全?
先加 C 的話,C 可能在 Cancel 之前就把 $1 花掉,錢追不回來。右邊選 Choice 2 試試。
📖 原書 三種看起來都合理,但有些無效:
- 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 先到:沒有東西可以取消
這一步要解決的問題網路慢,「取消」比「做」先到,怎麼辦?
📖 原書 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懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
照清單一步一步做;哪一步出錯,就倒著一步一步補
① 先想像
媽媽有一張清單:① 從哥哥拿 $1 ② 放進妹妹 ③ 記進家庭帳本。照順序做,一步做完才做下一步;出錯就倒回去,把做過的每一步反過來做。
你猜猜看:清單有 3 步,每一步都要事先準備好「反向動作」。總共要準備幾個動作?
3 個正向 + 3 個反向 = 6 個。原書說 n 個操作要準備 2n 個。
③ 這叫做 Saga、orchestration
Saga:一串依序做、各自完成的小 transaction,失敗就倒著補償。orchestration:由一個人(媽媽)照清單指揮大家。另見 22 章(機票 + 飯店)。
④ 跟這章的關係
原書 Figure 13(第 26 頁)。和 TC/C 的差別:Saga 一次只做一步;TC/C 可以同時問兩邊。
② 動手玩:選一步讓它出錯
按「執行」。
原書 Step 2 · 高階方案Saga · Linear order execution · Figure 13
Saga:一步一步往前做,失敗就一步一步往回補
這一步要解決的問題另一種補償做法:排好順序,一步一步來。
📖 原書 另一個流行的分散式交易方案是 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/C | Saga | |
| Compensating action | In Cancel phase | In rollback phase |
| Central coordination | Yes | Yes (orchestration mode) |
| Operation execution order | any | linear |
| Parallel execution possibility | Yes | No (linear execution) |
| Could see the partial inconsistent status | Yes | Yes |
| Application or database logic | Application | Application |
📖 原書 用哪一個?看延遲需求:Saga 必須線性執行,TC/C 可以平行。沒有延遲需求、或服務很少(像這個轉帳例子),兩個都行;想跟上微服務的潮流就選 Saga。對延遲敏感、服務/操作很多,TC/C 可能較好。
應徵者:為了讓轉帳有交易性,用關聯式資料庫取代 Redis,用 TC/C 或 Saga 實作分散式交易。面試官:很好!但有些情況不適用:使用者可能在應用層輸入錯誤的操作,導致金額不對。需要能追蹤問題根源、稽核所有帳戶操作,怎麼做?
到這裡你已經會了小結 2 / 5
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
到這裡你已經會了:兩個房間一起改的三種做法
- 2PC:先問兩邊「可以嗎」,按住等全部說好才一起簽;媽媽昏倒,兩邊就一直按著。
- TC/C:先真的做,錯了用反向動作補回;中間那一下,兩個存錢筒加起來少 $1。
- Saga:照清單一步一步做,出錯就倒著補;n 步要準備 2n 個動作,扣款放第一步。
下一階要解決的問題
面試官又問:使用者打錯、程式有 bug,錢算錯了,怎麼追到是哪一筆、哪一天?
延伸基礎第 8 階 · event sourcing懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
帳本只記每一筆,不改餘額
① 先想像
不在存錢筒外面貼「現在有 $5」,而是在一本流水帳上,每次進出寫一行:「媽媽給哥哥 +$2」「哥哥買糖 −$4」。寫過的行不擦掉,只往後加;想知道現在多少,就從頭加起來。
你猜猜看:哥哥的流水帳是 +5、−1、+3、−2。哥哥現在有多少?
5 − 1 + 3 − 2 = 5。餘額不用另外記,加起來就有。
③ 這叫做 event、event sourcing
event:一行「已經發生的事」,用過去式寫。event sourcing:只存 event,餘額用從頭加總(重播)算出來。
④ 跟這章的關係
原書的設計 ③(第 31 頁)。Triton 對「餘額用加總算」有話要說(第 52 頁)。
② 動手玩:改數字 vs 記流水帳
延伸基礎第 9 階 · reproducibility懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
同一本流水帳,誰來重算都要得到一樣的數字
① 先想像
月底發現少了 $3。拿流水帳從第一行重算,算到哪一行開始對不上,就知道錯在哪一筆。前提是每一行都寫死了:不能寫「看心情給」。
你猜猜看:有一行寫的是「哥哥 +(擲一次骰子的點數)」。爸爸和奶奶各自重算,結果會一樣嗎?
每次擲都可能不同。所以流水帳上要寫「擲到了 4,哥哥 +4」,不是「擲一次」。
③ 這叫做 reproducibility、deterministic
reproducibility(可重現性):從頭重播,能重建任何時間點的狀態。deterministic(確定性):同樣的輸入,永遠得到同樣的結果。
④ 跟這章的關係
面試官的需求(第 6 頁);原書 Figure 18 重播歷史(第 34 頁)。
② 動手玩:重播到第幾行
原書 Step 2 · 設計 ③Event sourcing · Background · Definition
審計員的三個問題,和 event sourcing 的四個名詞
這一步要解決的問題面試官要「追得到錯在哪一筆」:帳要怎麼記?
📖 原書 外部審計員可能會問
- 任意時間點的帳戶餘額是多少?
- 怎麼確定歷史和目前的餘額是正確的?
- 程式改版之後,怎麼證明系統邏輯仍然正確?
系統性回答這些問題的設計理念是 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
靜態看:兩個狀態機;動態看:指令、事件、狀態三條線
這一步要解決的問題指令、事件、狀態三樣東西,怎麼一起運作?
📖 原書 狀態機把指令轉成事件、再套用事件。因為它有兩個主要功能,通常畫成兩個狀態機:一個驗證指令、一個套用事件。
📖 原書 加上時間維度:系統持續收到指令,一個接一個處理。每個指令 Validate 成事件,事件 Apply 成新的狀態。
原書 Step 2 · Event sourcingWallet service example · Figure 16–17
錢包版:Kafka 當指令佇列,狀態機五個步驟
這一步要解決的問題放到錢包上:一筆轉帳指令,會變成哪些事件?
📖 原書 對錢包服務來說,指令就是轉帳請求,放進 FIFO 佇列,熱門選擇是 Kafka(一種排隊系統,19 章;Figure 16)。假設狀態(餘額)存在關聯式資料庫。狀態機照 FIFO 順序一個個檢查指令:餘額夠,就為每個帳戶各產生一個事件。指令「A->$1->C」產生「A:-$1」和「C:+$1」兩個事件。
- 從指令佇列讀取指令
- 從資料庫讀取餘額狀態
- 驗證指令;有效的話,為兩個帳戶各產生一個事件
- 讀取下一個事件
- 更新資料庫裡的餘額,套用事件
原書 Step 2 · Event sourcingReproducibility · Figure 18
可重現性:事件不可變、狀態機確定,所以每次重播都一樣
這一步要解決的問題有了流水帳,審計員的三個問題怎麼答?
📖 原書 event sourcing 相較其他架構最重要的優勢就是可重現性。前面的分散式交易方案裡,wallet service 把更新後的餘額存進資料庫,很難知道餘額為什麼變了,而且更新時歷史餘額就遺失了。event sourcing 裡,所有變更先以不可變的歷史保存,資料庫只是某個時間點餘額的更新後視圖。
📖 原書 回答審計員的三個問題
- 從頭重播事件,停在想知道的時間點
- 從事件列表重新計算,驗證餘額正確
- 對同一串事件跑不同版本的程式,比對結果是否相同
📖 原書 因為具備審計能力,event sourcing 常被選為錢包服務的事實標準。
延伸基礎第 10 階 · CQRS懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- 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 要怎麼查餘額?
📖 原書 到目前為止錢包能轉帳了,但 client 還不知道餘額是多少。要有方法發布狀態給 event sourcing 框架外的 client。直覺做法是建一個資料庫唯讀副本分享出去;event sourcing 的答法不一樣:不發布狀態,而是發布所有事件,外面自己重建任何想要的狀態。這個設計理念叫 CQRS。
- 一個狀態機負責狀態的寫入,但可以有多個唯讀狀態機建構不同的視圖供查詢
- 例如一個存餘額給 client 查;另一個建構特定時間區間的狀態,用來調查重複扣款;這些狀態就是核對財務紀錄的稽核軌跡
- 唯讀狀態機會有延遲,但最終會趕上:最終一致性
應徵者:所有有效的業務紀錄都在不可變的事件佇列裡,可以驗證正確性。面試官:但這個架構一次只處理一個事件,還要跟多個外部系統溝通。能更快嗎?
原書 Step 3High-performance event sourcing · Figure 20–21
不走網路:指令、事件、狀態都存本地檔案,用 mmap
這一步要解決的問題每處理一筆都要走網路去 Kafka 和資料庫,太慢:能不能全部放在本機?
📖 原書 先前用 Kafka 存指令與事件、資料庫存狀態。優化:
- 指令與事件存本地磁碟,不走遠端的 Kafka,省掉網路傳輸。事件列表是 append-only:順序寫入通常非常快,連傳統硬碟都行,因為作業系統對順序讀寫做了大量優化。原書引 ACM Queue 的文章:某些情況下,順序磁碟存取甚至比隨機記憶體存取還快
- 把最近的指令與事件快取在記憶體,省下從本地磁碟重新載入的時間
- 實作:mmap(把檔案當記憶體用)把磁碟檔案映射成記憶體陣列,同時寫入本地磁碟、快取最近的內容;append-only 的檔案幾乎保證全在記憶體裡
📖 原書 狀態也一樣:資料庫通常在另一台伺服器、只能透過網路存取,改存本地。可用 SQLite(本地檔案型關聯式資料庫)或 RocksDB(本地檔案型 KV)。原書選 RocksDB:它用 LSM tree(先寫記憶體、滿了整批寫檔,06 章),對寫入最佳化;最近的資料會被快取以提升讀取效能。
延伸基礎第 11 階 · snapshot懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
每個月底抄一次結餘,查帳不用從第一天加起
① 先想像
流水帳寫了三年,查一個舊日子的餘額要從第一行加好幾萬行。如果每個月底在帳本上抄一行「月底結餘」,就只要從最近的那一行往後加。
你猜猜看:每天 10 行、已經寫了 300 天,每 30 天抄一次結餘。查第 295 天的餘額,最多要加幾行?
最近的結餘在第 270 天。從那裡加第 271–295 天:25 天 × 10 行 = 250 行。
③ 這叫做 snapshot
snapshot:某個時間點、整份狀態的快照(月底結餘)。之後要查,只要「快照 + 後面的流水帳」。
④ 跟這章的關係
原書 Figure 22 每天 00:00 拍一次(第 39 頁);Triton 的 081 也一樣,只是放在資料庫的一張表(第 60 頁)。
② 動手玩:結餘抄在哪一行後面
藍色=要一行一行加的;灰色=已經包含在結餘(📌)裡。
原書 Step 3Snapshot · Figure 22
Snapshot:定期把狀態存成檔,重播不用從第一天開始
這一步要解決的問題流水帳越來越長,重算越來越慢,怎麼辦?
動手試:查第 N 天的餘額要重播多少事件?
📖 原書 一切都檔案化之後,來加速可重現性。原本狀態機每次都要從頭處理事件;可以定期暫停狀態機,把目前的狀態存成檔案,這叫 snapshot。
- Snapshot 是歷史狀態的不可變視圖。存好之後,狀態機不必從頭開始:讀 snapshot、確認停在哪裡,從那裡繼續
- 財務團隊常要求在 00:00 拍 snapshot,才能驗證當天所有交易。原本 CQRS 要讓唯讀狀態機從頭讀到指定時間;有 snapshot 之後只要載入一個 snapshot
- Snapshot 是一個巨大的二進位檔,常見做法是放在物件儲存(專門放大檔案的倉庫),例如 HDFS
📖 原書 一切都檔案化後,系統能用滿電腦硬體的最大 I/O 吞吐量。面試官:本地檔案比遠端 Kafka 和資料庫快。但資料在本地磁碟,伺服器變成 stateful,而且是單點故障。怎麼提升可靠性?
到這裡你已經會了小結 3 / 5
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
到這裡你已經會了:只記流水帳的錢包
- event sourcing:帳本只記每一筆、不改餘額;餘額是從頭加起來算的。要求不合理就拒絕,不寫進帳本。
- 每一行都是寫死的結果(deterministic),誰重算都一樣:這就是 reproducibility。
- 寫一本、查另一本(CQRS),查的會晚一點;月底抄結餘(snapshot),重算不用從第一天加。
下一階要解決的問題
為了快,原書把流水帳放在單一台電腦的本機檔案裡。這台電腦壞了怎麼辦?
延伸基礎第 12 階 · Raft懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
流水帳抄三份:過半數抄好,這一行才算數
① 先想像
流水帳只有一本,燒掉就沒了。請小明、小華、小美三位一起抄:班長寫一行就唸給另外兩位聽,至少兩位(含班長)抄好,這一行才算數。班長請假,就從在場的人選一位新班長。
你猜猜看:5 位一起抄,最多可以幾位請假,帳本還能繼續寫?
要過半數:5 位裡至少 3 位在場。所以最多 2 位請假。原書:3 台能容忍 1 台壞、5 台能容忍 2 台。
④ 跟這章的關係
原書用 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 列表就有相同資料。
📖 原書 Raft 的三種角色
Leader、Candidate、Follower。叢集最多只有一個 leader,其他是 follower。Leader 接收外部指令,並可靠地把資料複製到叢集的節點。3 個節點能容忍 1 個故障;5 個能容忍 2 個。
原書 Step 3Reliable solution · Figure 24
三個 event sourcing 節點組成一個 Raft 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
轉完帳想馬上知道結果:輪詢、加反向代理、改成推送
這一步要解決的問題轉完帳要馬上知道結果;一組機器不夠時,還要分片。
📖 原書 可靠的高效能 event sourcing 還有兩個限制:
- 希望錢包更新後立刻收到結果。但 CQRS 的請求/回應可能較慢:client 不知道錢包何時更新,只能定期輪詢
- 單一 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 在不同的分片上,轉帳怎麼做?
📖 原書 一旦每個 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 個步驟
這一步要解決的問題一筆成功的跨分片轉帳,實際走了哪些步驟?
- 使用者 A 送一個分散式交易給 Saga coordinator:兩個操作 A−$1、C+$1
- coordinator 在 phase status table 建一筆紀錄,追蹤交易狀態
- coordinator 檢查操作順序,決定先處理 A−$1,把它當指令送到放帳戶 A 的 Partition 1
- Partition 1 的 Raft leader 收到指令、存進指令列表、驗證;有效就轉成事件,用 Raft 同步各節點;同步完成後執行事件(A 扣 $1)
- 事件同步完成後,Partition 1 用 CQRS 把資料同步到 read path,重建狀態與執行狀態
- Partition 1 的 read path 把狀態推回給呼叫者,也就是 Saga coordinator
- coordinator 收到 Partition 1 的成功狀態
- coordinator 在 phase status table 記下 Partition 1 成功
- 第一個操作成功,coordinator 執行第二個:把 C+$1 當指令送到 Partition 2
- Partition 2 的 Raft leader 收到、存進指令列表;有效就轉成事件、Raft 同步,同步完成後執行(C 加 $1)
- Partition 2 用 CQRS 同步到 read path,重建狀態與執行狀態
- Partition 2 的 read path 把狀態推回 Saga coordinator
- coordinator 收到 Partition 2 的成功狀態
- coordinator 在 phase status table 記下 Partition 2 成功
- 所有操作成功,分散式交易完成,coordinator 回應呼叫者
原書 Step 4Wrap up · Chapter summary
原書的收尾:五個設計,一路演進
這一步要解決的問題回頭看:五個設計,各解決了什麼、又製造了什麼?
- 📖 設計一個每秒處理超過 100 萬筆付款指令的錢包服務;估算後需要數千個節點
- 第一個設計:類似 Redis 的 in-memory KV。問題:資料不具持久性
- 第二個設計:換成交易型資料庫;為了多節點,提出 2PC、TC/C、Saga。問題:不容易做資料稽核
- 接著引入 event sourcing:先用外部資料庫與佇列,效能不佳;改成在本地節點存指令、事件、狀態
- 單一節點是單點故障:用 Raft 把事件列表複製到多個節點
- 最後採用 CQRS,加上反向代理,把非同步的 event sourcing 框架變成對外同步;用 TC/C 或 Saga 協調多個節點群組間的指令
原書到這裡結束(原書還說了一句:恭喜你走到這裡,給自己一個讚)。下一頁開始是 Triton 的觀點。
到這裡你已經會了小結 4 / 5
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
到這裡你已經會了:原書的完整設計
- 流水帳抄三份,過半數抄好才算數(Raft);班長壞了就換人,指令重送。
- 轉帳結果用 push 立刻送回,不讓使用者一直來問(pull)。
- 最終設計:每個分片一組 Raft;跨分片的轉帳,還是回到第 5–7 階的 TC/C 或 Saga。
下一段:Triton 的觀點
Triton 會從第 3 階開始質疑:為什麼兩個存錢筒一定要放在兩個房間?
Triton 觀點總覽
原書一路加元件;Triton 會先問:為什麼帳戶一定要在兩台機器上?
原書這樣做會出什麼事?最後的設計(第 45 頁)裡,A 和 C 在不同分片時,還需要 TC/C 或 Saga 嗎?
Figure 28:每個分片一組 Raft,跨分片的轉帳還是靠 TC/C 或 Saga。Triton 那句「也是避不了這堆問題的」就是在講這個。
📖 原書的路線
- Redis 分片 → 不持久、不 atomic
- RDBMS 分片 + 2PC / TC/C / Saga → 不好稽核
- Event sourcing + Kafka → 慢
- 本地檔案 + mmap + RocksDB → 單點故障
- Raft group → 一組不夠 1M TPS
- 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 次寫入才落盤一次),半夜停電。早上會怎樣?
還沒落盤的那一批跟著停電消失(第 9 頁的白板)。A、B 在不同台,兩台落盤的時間點不同,可能 A 扣了、B 沒加。右邊按「斷電」看看。
「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懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
兩台 ATM 同時看到 $100,各吐出 $80
① 先想像
哥哥和妹妹拿同一個帳戶的卡,在兩台 ATM 同時領錢。兩台都先看餘額「還有 $100,夠」,再各自扣 $80。
你猜猜看:帳戶 $100,兩台都在對方扣款之前看了餘額。最後一共吐出多少現金?
兩台看到的都是 $100,都覺得夠。第二台看到的數字,在它扣款前已經過期了。
③ 這叫做 race condition、atomic check-and-set
race condition:兩人同時「先看、再寫」,有一人根據過期的數字做決定(22 章)。atomic check-and-set:「夠不夠」和「扣款」是同一個動作,中間不能插隊(22 章)。
④ 跟這章的關係
Triton 177 用這個例子,比較「只記流水帳」和「一句有條件的 UPDATE」(下一頁)。
② 動手玩:兩台 ATM
Triton 觀點 · 動手玩177 · 對照原書的 event sourcing
同一個人在兩台 ATM 同時提款:sum(delta) vs 一句 UPDATE
原書這樣做會出什麼事?如果只記流水帳(user_activity),帳戶 $100,兩台 ATM 同時各領 $80,都先用加總確認「夠」。
兩台加總時都看到 $100,就是上一頁的 race condition。177 的答案是一句有條件的 UPDATE。
帳戶有 $100,兩台 ATM 各要提 $80。
「如果現在系統是用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 時,這句會?
WHERE 只比帳號、沒比餘額。把「夠不夠」寫進 WHERE,就找不到符合的那一列:AffectedRow = 0,Try 失敗。
📖 原書 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懂的人可以跳過
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- 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 來改兩個帳戶。會怎樣?
一個先改 A 再改 B,另一個先改 B 再改 A:就是上一頁的 deadlock。照 userID 排序,大家順序一樣就沒事。
「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 台,隨便挑兩個帳戶轉帳,要跨機器(需要分散式交易)的大約占多少?
同一台的機會只有 1/2,000(第 10 頁的房間)。下面把 N 拉到 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% 的轉帳都打到同一個外送平台的錢包,系統每秒最多幾筆?
那個錢包住在一片上,那片每秒只做 1 萬筆:1 萬 ÷ 5% = 20 萬。加分片也不會變。
白話: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),一台每秒能做的會?
等落盤的 1 ms 由 1,000 筆一起分攤。下面把 batch 拉到 1,000:約 980 → 約 47,600 TPS,2,000 台變約 42 台(示意)。
動手算:Table 1 的「每節點 TPS」不是固定的
Triton 觀點 · 動手玩081 · 對照原書的可重現性與 snapshot
在 RDBMS 裡回答審計員的三個問題:流水帳、snapshot、banker
原書說可重現性要靠 event sourcing。Triton 的 081:每筆交易同時改 user_balance 和 banker(銀行那一格)。所有人餘額加上 banker,應該等於?
使用者多一塊,banker 就少一塊,加起來永遠是 0。不是 0 就是有 bug:這叫「驗血」。
「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
🔭 對照原書三個審計問題
- 任意時間點的餘額:snapshot + 那之前的
user_activity加總(滑桿) - 歷史與目前餘額正確:banker 加總為零(驗血)、逐人比對(MRI)
- 改版後邏輯仍正確:同一份 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) |
| Reproducibility | account_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 覺得微服務主要在解決什麼問題?
隔離災情、不讓別的 team 亂改 code:都是人多才有的問題(22 章)。
📖 原書
「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 說的微服務兩個目的
- 讓一個 while(1) bug 的災情只局限在出事的 module,而不是全公司 global outage(FAANG 過萬個 dev 的規模)
- 不讓別的 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
- TPS
- Redis
- sharding
- transaction
- 2PC
- TC/C
- Saga
- event sourcing
- reproducibility
- CQRS
- snapshot
- Raft
- race condition
- deadlock
到這裡你已經會了:Triton 怎麼修
- 錢放 RDBMS;扣款寫成一句「夠才扣」的 UPDATE,沒有 race condition,看 AffectedRow 就知道成不成功。
- 一次要改兩個存錢筒,照編號順序拿鑰匙,就不會 deadlock。流水帳和餘額寫在同一個 transaction 裡,可以互相對帳。
- 跨機器就躲不掉 2PC,event sourcing 也一樣。所以先 scale up,別讓轉帳跨機器。
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)
本章名詞小卡課後複習用 · 每個名詞一句白話
今天出現的名詞,一句話講完
給工程師的重點出處與標籤
引述來源(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 在每個步驟之間當機會怎樣?