System Design Interview Vol. 2 · 第 7 章Triton 覆蓋度:🟢 高Triton 線
Hotel Reservation System
最後一間房,只能賣一次
原書替 Marriott 這種連鎖飯店設計訂房系統:以 room type 為單位的庫存表、三種防止重複訂房的鎖、依 hotel_id 分片、Redis 庫存快取,最後談 microservice 之間的 2PC 與 Saga。Triton 在搶票和戲院售票上的答案簡單得多:一句 atomic 的 UPDATE … WHERE remaining > 0,保留時間到了自己過期,金流放在 transaction 外面。
給文組
全程用「海景旅館跨年夜的最後一間房」(虛構)和 Triton 自己的「廁所比喻」,一階一階爬 13 個概念。頁首標 延伸基礎 的頁是補基礎,懂的人可以跳過。
給工程師
第 5–42 頁完整講原書:Table 1–5、所有 SQL 和 API 照錄,20 張圖裡 19 張依原書內容重繪(Figure 9 是 app 截圖,不重繪,說明在第 22 頁)。後面是 Triton 的觀點,最後一頁列出所有出處(materials/core)與頁碼對照。
標籤怎麼看
📖 原書 🗣️ Triton 本人說 🔭 依 Triton 原則推論 📝 上課筆記 💬 討論串回覆,作者未標示 📅 2026 補充
先用生活理解海景旅館的訂房簿
訂房簿上寫「剩 1 間」,兩個櫃台同時接到電話
這就是 race condition
「看一眼」和「寫上去」中間只隔幾秒,另一個櫃台就能插進來。兩個人都看到「剩 1 間」,都跟客人說「幫您訂好了」,晚上兩組客人拿著同一間房的確認信到櫃台。
改成一個動作:「簿子上還有空格,就直接劃掉一格;沒有就說客滿」。誰先劃到算誰的,另一個人劃不到,當場就知道。
第二個比喻:訂位保留 15 分鐘
餐廳白板寫「王先生 19:00,保留到 19:15」。過了 19:15,店員看一眼時鐘就知道這桌可以給別人,不需要有人記得去擦白板。後面 Triton 的戲院售票就是這個做法(第 47 頁)。
原書接下來要談的鎖、快取、分片、2PC,都是在處理「兩個櫃台同時看簿子」這件事,只是規模放大到 5,000 間飯店。
學習地圖本章的概念階梯
今天爬 13 階。每一階只用前面講過的東西。
- 1TPS每秒幾張訂房單
- 2transaction要嘛全做、要嘛全不做
- 3microservice每個部門一個櫃子
- 4inventory table每晚每種房型一行
- 5double booking一房兩賣
- 6idempotency key同一張號碼按兩次
- 7race condition看和寫中間被插隊
- 8pessimistic lock先把簿子抱走
- 9optimistic lock寫回時看版本號
- 10DB constraint簿子自己拒絕
- 112PC婚禮上兩人都說願意
- 12Saga訂不到就退機票
- 13atomic CAS還有空格才劃掉
第 1–3 階 · 一張訂房單走進系統
要回答:原書的系統分成哪幾塊?
第 4–6 階 · 庫存表與按兩次
要回答:住三晚改幾行?按兩次怎麼只算一次?
第 7–10 階 · 很多人搶最後一間
要回答:原書的三種鎖差在哪?
第 11–12 階 · 拆成很多本帳簿
要回答:一筆訂房跨兩個資料庫怎麼辦?
第 13 階 · Triton 的修法
要回答:一句 UPDATE 怎麼搞定?
全程只用一家旅館:海景旅館跨年夜(虛構)
12/31 海景雙人房,100 間、已訂 99 間:最後一間。每爬 2–4 階,有一頁「到這裡你已經會了」。
延伸基礎第 1 階 · TPS(複習 request、QPS)懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
一天 24 萬人按「訂房」,櫃台每秒要接幾張單?
① 先想像
跨年夜前,100 個人打開海景旅館的網頁看房,10 個人填了資料,只有 1 個人按下「訂房」。
你猜猜看:一天有 24 萬人按下「訂房」,平均每秒幾人?
一天 86,400 秒,抓 10 萬秒好算:24 萬 ÷ 10 萬 ≈ 2.4,原書寫「約 3」。看房的人比這多 100 倍。
③ 這叫做 request、QPS/TPS
request:送出去的一張單子,看房、填資料、訂房都是。QPS/TPS:每秒幾張單;TPS 專指真的要寫進帳本的交易。request 的完整版:04 章QPS 的完整版:02 章
④ 跟這章的關係
原書算出全站每秒只有約 3 筆訂房(第 6 頁)。Triton 之後會問:跨年夜那一間房,同一秒有幾個人在搶?
② 動手玩:每一步只有一部分人走到下一步
原書 Step 1釐清需求
面試一開始:多大、什麼時候付錢、可以取消、可以超賣
這一步要解決的問題做多大?什麼時候付錢?能不能取消、能不能多賣?先問清楚再畫圖。
📖 原書 應徵者 × 面試官
| 應徵者問 | 面試官答 |
|---|---|
| 系統規模多大? | 連鎖飯店的網站:5,000 間飯店、總共 100 萬間客房 |
| 客人訂房時付錢,還是到飯店才付? | 為了簡化,訂房時全額付款 |
| 只能從飯店網站訂嗎?要支援電話訂房嗎? | 網站或 app 都能訂 |
| 客人可以取消嗎? | 可以 |
| 還有其他要考慮的嗎? | 允許 10% overbooking:飯店會賣出比實際房間更多的數量,因為預期有人會取消 |
| 時間有限,我假設房間搜尋不在範圍內 | (應徵者列出下面五個功能)面試官:聽起來不錯 |
| 面試官補充:房價是動態的,取決於那一天飯店預期多滿,可以假設每天價格都不同。應徵者:我會記住。 | |
📖 原書 這章的技術也適用於其他訂位題:Design Airbnb、航班訂票、電影票訂票。
先記住第一條 NFR:「很多人同時訂同一間房」。原書後面挑鎖的時候說「QPS 通常不高,所以選樂觀鎖」,Triton 會拿這一條回頭問:那大型活動那一晚呢?(第 45 頁)
📖 原書 要做的功能
- 顯示飯店相關頁面
- 顯示房間的詳細頁面
- 訂房(Reserve a room)
- 管理後台:新增、移除、更新飯店或房間資訊
- 支援 overbooking
📖 原書 Non-functional requirements
- Support high concurrency:旺季或大型活動時,熱門飯店可能有很多人同時想訂同一間房
- Moderate latency:訂房時回應快最好,但處理一筆訂房花幾秒鐘也可以接受
白話:non-functional requirements=不是功能,是品質要求;concurrency=很多人同時做同一件事;latency=要等多久才有回應。
原書 Step 1Back-of-the-envelope estimation · Figure 1
每秒只有 3 筆訂房,往上推是 30、300
這一步要解決的問題一天會有多少筆訂房?每秒幾筆?讀和寫哪個多?
📖 原書 估算
- 5,000 間飯店、100 萬間房
- 假設 70% 的房間有人住、平均住 3 天
- 每天訂房數:(100 萬 × 0.7) / 3 = 233,333,進位約 240,000
- 每秒訂房數 = 240,000 / 一天 105 秒 ≈ 3。平均 TPS 不高
📖 原書 三個步驟的 QPS
- 看飯店/房間詳細頁(query)
- 看訂房頁:確認日期、人數、付款資訊(query)
- 按「book」訂房(transaction)
假設每一步只有 10% 的人走到下一步、沒有做 prefetching。從最後的 TPS 3 往回推:訂單確認頁 30、詳細頁 300。
文組翻譯:一百個人逛櫥窗,十個人走進店裡試穿,一個人結帳。收銀台每秒只有 3 個人,逛櫥窗的才是大宗。
原書 Step 2API design · Table 1–3
三組 RESTful API:飯店、房間、訂單
這一步要解決的問題客人和飯店員工,各要透過哪些窗口送單子進來?
| API | Detail |
|---|---|
| Table 1 · Hotel-related APIs | |
GET /v1/hotels/ID | 取得飯店詳細資訊 |
POST /v1/hotels | 新增飯店。只有飯店員工能用 |
PUT /v1/hotels/ID | 更新飯店資訊。只有飯店員工能用 |
DELETE /v1/hotels/ID | 刪除飯店。只有飯店員工能用 |
| Table 2 · Room-related APIs | |
GET /v1/hotels/ID/rooms/ID | 取得房間詳細資訊 |
POST /v1/hotels/ID/rooms | 新增房間。只有飯店員工能用 |
PUT /v1/hotels/ID/rooms/ID | 更新房間資訊。只有飯店員工能用 |
DELETE /v1/hotels/ID/rooms/ID | 刪除房間。只有飯店員工能用 |
| Table 3 · Reservation-related APIs | |
GET /v1/reservations | 登入使用者的訂房紀錄 |
GET /v1/reservations/ID | 某筆訂單的詳細資訊 |
POST /v1/reservations | 建立新訂單 |
DELETE /v1/reservations/ID | 取消訂單 |
注意這裡的 request 帶的是 roomID,指定「哪一間房」。原書馬上會說這是個問題:飯店客人訂的其實是「房型」(第 10 頁)。
📖 原書 完整的飯店網站要讓客人用各種條件搜尋房間。這些搜尋 API 很重要,但技術上不難,不在本章範圍。
白話:API=系統公開的窗口;RESTful=用 GET(看)、POST(新增)、PUT(改)、DELETE(刪)四個動詞加網址來點單。
📖 原書 建立訂單的 request
POST /v1/reservations
{
"startDate":"2021-04-28",
"endDate":"2021-04-30",
"hotelID":"245",
"roomID":"U12354673389",
"reservationID":"13422445"
}
reservationID 是 idempotency key,用來防止 double booking(同一天同一間房被訂了好幾次)。細節在 deep dive 的 Concurrency issue(第 20 頁)。
白話:idempotency key=同一張訂單號碼,按兩次也只算一次(第 21 頁);double booking=同一間房被訂兩次(第 19 頁)。
延伸基礎第 2 階 · transaction懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
訂兩晚,劃到一半停電了
① 先想像
王先生訂 12/30、12/31 兩晚。櫃台劃掉 12/30 那格,正要劃 12/31,停電了。
你猜猜看:電來了,簿子上會是什麼樣子?
做到一半的動作留在簿子上,12/30 這間房被白白佔掉。右邊試試「包成一個 transaction」。
③ 這叫做 transaction、commit/rollback
transaction:一組動作,要嘛全做、要嘛全不做。commit/rollback:全部確定寫入/全部撤銷,回到開始前。transaction 的完整版:07 章
④ 跟這章的關係
原書選 relational database,理由之一就是它有 transaction(下一頁的 ACID)。住幾晚都在同一個 transaction 裡改。
② 動手玩:劃到一半按停電
原書 Step 2Data model · Figure 2
先看要查什麼,再選資料庫:原書選 relational
這一步要解決的問題要存哪些資料?用哪一種資料庫?
📖 原書 要支援的查詢
- 查看飯店的詳細資訊
- 給定日期範圍,找出還有空房的房型
- 記錄一筆訂房
- 查詢一筆訂房,或過去的訂房紀錄
📖 原書 為什麼選 relational database
- 讀多寫少:逛網站的人比真正訂房的人多好幾個數量級。原書說 NoSQL 通常為寫入最佳化,RDBMS 對讀多的流程夠好
- ACID:沒有它,很難防止負餘額、重複扣款、重複訂房;ACID 讓程式碼簡單很多,整個系統也更好推理
- 好建模:飯店、房間、房型之間的關係清楚又穩定
白話:relational database(RDBMS)=一格一格的表,表和表用編號對起來;NoSQL=不用固定表格的資料庫;ACID=transaction 的四個保證(第 8 頁)。
規模不大,但要準備好大型活動時的流量暴增。
reservation 的 status 有五種:pending、paid、refunded、canceled、rejected。原書說這是「很多應徵者最自然的建模方式」,下一頁會指出它的大問題。
原書 Step 2Reservation status · Figure 3 · 這個 schema 的大問題
訂單的五種狀態,以及「客人訂的不是 812 號房」
這一步要解決的問題一筆訂單會經過哪些狀態?客人訂的到底是哪一間房?
📖 原書 這個 schema 有個大問題
這個資料模型適合 Airbnb:使用者訂房時就指定了 room_id(可能叫 listing_id)。但飯店不是這樣:客人訂的是某間飯店的一種房型,例如 standard room、king-size room、兩張 queen 床的雙人房。
房號是 check-in 時才給的,不是訂房時。所以資料模型要改,細節在 deep dive 的「Improved data model」(第 16 頁)。
文組翻譯
訂高鐵自由座,你買的是「這班車的一個位子」,不是「5 車 12A」。系統要數的是「這班車還剩幾個位子」,不是每個位子有沒有人。飯店訂房也一樣:要數的是「這一晚、這種房型,還剩幾間」。
延伸基礎第 3 階 · microservice懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
一個老闆一本簿子,還是每個部門一個櫃子?
① 先想像
民宿老闆一個人,用一本簿子記房間、房價、訂單。大飯店分成訂房部、定價部、收銀部,各有自己的檔案櫃。
你猜猜看:大飯店的定價部電腦當機了,訂房部還能完成訂房嗎?
分開的是櫃子,不是工作。訂房要問價錢,定價部一停,訂房也跟著停。右邊比較兩種店。
③ 這叫做 monolith、microservice
monolith:一個大程式,大家共用一本帳。microservice:拆成很多小服務,各自一個資料庫,用網路互相打電話。
④ 跟這章的關係
原書的 Figure 4 用 microservice(下一頁)。到第 38 頁,原書自己又把訂單和庫存放回同一本帳。
② 動手玩:定價那一塊壞掉
原書 Step 2High-level design · Figure 4
原書用 microservice:每個服務一個資料庫
這一步要解決的問題整個系統分成哪幾個部門?一張單子從客人手機走到哪裡?
📖 原書 近年 microservice 很流行,Amazon、Netflix、Uber、Airbnb、Twitter 都在用。由上往下:
- User:用手機或電腦訂房 · Admin(飯店員工):退款、取消訂單、更新房間資訊
- CDN:cache 所有靜態資源(JavaScript bundle、圖片、影片、HTML)
- Public API Gateway:全託管服務,支援 rate limiting、authentication;依 endpoint 把 request 導到各服務
- Internal APIs:只給授權的員工,通常再用 VPN 保護
- Hotel Service:飯店和房間資訊,大多是靜態的,很好 cache
- Rate Service:未來各日期的房價;房價取決於那天預期多滿
- Reservation Service:接訂房 request、預訂房間,也追蹤房間庫存
- Payment Service:收款;成功把訂單改成
paid,失敗改成rejected - Hotel Management Service:只給員工:看即將到來的訂單、替客人訂房、取消訂單
白話:CDN=離客人最近的影本架(01 章);API Gateway=大門的總接待,順便限流(04 章);authentication=確認你是誰;VPN=只有員工連得進的私人通道。
原書 Step 2Connections between services · Figure 5
Figure 4 為了好看,省略了服務之間的箭頭
這一步要解決的問題部門之間要怎麼互相打電話?
文組翻譯:每個部門有自己的檔案櫃。訂房部要算錢,得打內線問定價部;總務要改資料,得一個部門一個部門去敲門。部門越多,內線電話越多。
📖 原書 左:Reservation → Rate
Reservation Service 要向 Rate Service 查房價,才能算出一筆訂單的總房費。
📖 原書 右:Hotel Management → 其他服務
員工透過 Hotel Management Service 改東西時,request 會轉給真正擁有那份資料的服務去處理,所以它應該有很多箭頭連到大多數服務。
📖 原書 服務之間怎麼溝通
production 系統的服務間通訊,常用現代、高效能的 RPC framework,例如 gRPC,好處很多。
白話:RPC=像呼叫自己的程式一樣,去叫另一台機器做事;gRPC 是 Google 做的一套。
到這裡你已經會了小結 1 / 5
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
到這裡你已經會了:一張訂房單怎麼走進系統
- 每一張單子是一個 request。真正要寫進帳本的訂房,原書估全站每秒只有約 3 筆(TPS)。
- 改帳本要包成 transaction:要嘛全做、要嘛全不做,停電也不會只改一半。
- 原書把系統拆成 microservice:Hotel、Rate、Reservation、Payment 各自一個資料庫,用 gRPC 互相呼叫。
下一階要解決的問題
簿子上的「剩幾間」要怎麼記?住三晚要改幾行?原書在 deep dive 一開始就改了資料表。
延伸基礎第 4 階 · inventory table懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
簿子要記「哪一間房」,還是「這種房還剩幾間」?
① 先想像
高鐵自由座不賣「5 車 12A」,只數「這班車還剩幾個位子」。海景旅館的簿子也一樣:每晚、每種房型一行,寫總共幾間、已訂幾間。
你猜猜看:海景旅館有 2 種房型,簿子預先寫好未來 3 晚。簿子有幾行?
2 種 × 3 晚 = 6 行。原書是 5,000 間飯店 × 20 種房型 × 730 晚。
③ 這叫做 table/row、inventory table
table/row:資料庫裡的一張表/表上的一行。inventory table:庫存表,每晚每種房型一行,記總數和已訂數。
④ 跟這章的關係
原書的 room_type_inventory 就是這本簿子(下兩頁)。住幾晚,就要改幾行。
② 動手玩:訂一間,看改了哪幾行
原書 Step 3Design deep dive · Improved data model · Figure 6
改成訂「房型」:API 換成 roomTypeID,庫存另開一張表
這一步要解決的問題客人訂的是房型,不是房號:API 和資料表要怎麼改?
📖 原書 Deep dive 四個主題
- Improved data model
- Concurrency issues(第 20 頁起)
- Scaling the system(第 35 頁起)
- Resolving data inconsistency in the microservice architecture(第 38 頁起)
📖 原書 新的 request
POST /v1/reservations
{
"startDate":"2021-04-28",
"endDate":"2021-04-30",
"hotelID":"245",
"roomTypeID":"12354673389",
"roomCount":"3",
"reservationID":"13422445"
}
roomID 換成 roomTypeID,並多了 roomCount。
- room:一間房的資訊 · room_type_rate:某房型在未來各日期的價格 · reservation:客人的訂房資料
- room_type_inventory:飯店房間的庫存,「對訂房系統非常重要」,下一頁逐欄看
原書 Step 3room_type_inventory · Table 4 · 資料太大怎麼辦
每一晚、每一種房型,一列:總共 7,300 萬列
這一步要解決的問題庫存表一列長什麼樣?全部有多大?一台資料庫放得下嗎?
📖 原書 每一欄
hotel_id:飯店 ID ·room_type_id:房型 ID ·date:單一日期total_inventory:房間總數,減掉暫時下架(例如維修中)的total_reserved:這間飯店、這個房型、這一天已經被訂走的數量
一天一列,日期範圍內的訂房和查詢都好處理。(hotel_id, room_type_id, date) 是複合 PK。資料預先填好未來 2 年的每一天;有個每天跑的 scheduled job,日期往前推時補上新的一天。
| hotel_id | room_type_id | date | total_inventory | total_reserved |
|---|---|---|---|---|
| 211 | 1001 | 2021-06-01 | 100 | 80 |
| 211 | 1001 | 2021-06-02 | 100 | 82 |
| 211 | 1001 | 2021-06-03 | 100 | 86 |
| 211 | 1001 | ... | ... | |
| 211 | 1001 | 2023-05-31 | 100 | 0 |
| 211 | 1002 | 2021-06-01 | 200 | 16 |
| 2210 | 101 | 2021-06-01 | 30 | 23 |
| 2210 | 101 | 2021-06-02 | 30 | 25 |
📖 原書 Table 4Sample data of the room_type_inventory table
📖 原書 有多大?
原書:7,300 萬列不算多,一台資料庫就放得下。但一台就是 single point of failure,要 high availability 可以跨 region 或 availability zone 做 database replication。
白話:single point of failure=只有一台,它壞全部停;replication=即時影印到別台(01 章)。
📖 原書 面試官追問:訂房資料大到一台放不下?
- 只存目前和未來的訂房:歷史訂單很少被查,可以封存,有些甚至搬到 cold storage
- Database sharding:最常見的查詢(訂房、依姓名查訂單)都要先選飯店,所以
hotel_id是好的 sharding key,用hash(hotel_id) % number_of_servers分片
白話:cold storage=便宜但拿得慢的倉庫;sharding=依編號分成好幾本(第 35 頁)。
原書 Step 3用 room_type_inventory 判斷能不能訂 · Table 5 · overbooking
先 SELECT 那幾天,再一天一天檢查
這一步要解決的問題有了庫存表,怎麼判斷這幾晚還訂得到?
📖 原書 輸入:startDate (2021-07-01)、endDate (2021-07-03)、roomTypeId、hotelId、numberOfRoomsToReserve。輸出:這種房型有庫存、可以訂就回 True,否則 False。SQL 分兩步:
# 1. 選出日期範圍內的列
SELECT date, total_inventory, total_reserved
FROM room_type_inventory
WHERE room_type_id = ${roomTypeId} AND hotel_id = ${hotelId}
AND date between ${startDate} and ${endDate}
# 2. 每一列,由應用程式檢查
if (total_reserved + ${numberOfRoomsToReserve}) <= total_inventory
# 支援 10% overbooking 時
if (total_reserved + ${numberOfRoomsToReserve}) <= 110% * total_inventory
每一列都回 true,才代表日期範圍內每一天都有足夠的房間。原書:有了新的 schema,overbooking「很容易實作」。
動手試:用 Table 5 的資料訂房
📖 原書 Table 5Hotel inventory(SELECT 回來的三列)
延伸基礎第 5 階 · double booking懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
同一間房,寄出了兩封確認信
① 先想像
跨年夜,兩組客人拿著同一間房的確認信到櫃台。可能是王先生網路卡、按了兩次;也可能是王先生和李小姐同時按下最後一間。
你猜猜看:飯店故意多賣 10%,賭有人會取消。這也算 double booking 嗎?
原書把它叫 overbooking,是面試官給的需求;double booking 是沒有人想要的意外。
③ 這叫做 double booking、overbooking
double booking:同一個房間被意外訂了兩次。overbooking:飯店故意多賣一點,有上限。
④ 跟這章的關係
原書分兩種解:同一人按兩次(下三頁),很多人搶同一間(第 26 頁起)。
② 動手玩:三種「賣超過」
原書 Step 3Concurrency issues · 情境 1:同一個人連點兩次 · Figure 7
double booking 有兩種:同一個人點兩次、很多人搶同一間
這一步要解決的問題同一個人按了兩次「book」,怎麼只成立一筆?
📖 原書 要解決兩個問題:1) 同一個使用者按了好幾次「book」;2) 很多使用者同時想訂同一間房(第 26 頁)。先看第一種:兩次點擊,寫進兩筆一模一樣的訂單。
📖 原書 做法 1:Client-side
送出後把「submit」按鈕變灰、隱藏或停用。大部分時候可以防止連點,但不太可靠:例如使用者可以關掉 JavaScript,就繞過了 client 端的檢查。
📖 原書 做法 2:Idempotent APIs
在訂房 API 的 request 裡加一個 idempotency key。一個 API 呼叫,不管被呼叫幾次都產生同樣的結果,就叫 idempotent。下一頁用 Figure 8 看怎麼拿 reservation_id 當 key。
延伸基礎第 6 階 · idempotency key懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
同一張訂單號碼按兩次,只能算一次
① 先想像
網路掛號時,畫面先給你號碼 121。網路卡住,你又按了一次「送出」。櫃台看到「121 已經收過」,就不再收一次。
你猜猜看:如果 app 每按一次就產生新號碼(121、122、123),連按 3 次會成立幾筆?
號碼都不一樣,櫃台分不出是同一個人。號碼要在按之前就發好,按幾次都帶同一張。
③ 這叫做 idempotent、idempotency key
idempotent:同一件事做幾次,結果都一樣。idempotency key:那張先發好的號碼,按兩次也只算一次。另一個例子:10 章的重寄通知
④ 跟這章的關係
原書拿 reservation_id 當這張號碼,放在資料庫的 PK 上(下一頁)。
② 動手玩:連按「送出」
櫃台收到的單子
真正成立的訂單
原書 Step 3Idempotency key · Figure 8–10
先發一個 reservation_id,送出時帶著它,第二次就撞上唯一約束
這一步要解決的問題號碼什麼時候發?第二次送出是怎麼被擋下來的?
📖 原書 Figure 9 Confirmation page(不重繪)
原圖是 Booking.com iOS app 的畫面截圖(原書註明來源 [4]),有品牌 logo 和真實的飯店名稱,依規範產品截圖不重繪。alt 描述的內容:三步驟進度列(Your Selection、Your Details 已勾,Final Step 未勾)、San Francisco Marriott Marquis Union Square(4 星)、Wed, Jul 7, 2021 入住到 Sat, Jul 10, 2021、3 晚 King Room with No View、房價 $508、14% TAX $71.12、tourism fee $2.19、2.25% City tax $11.43、付款欄位(卡號、持卡人姓名預填 Alex、到期日 MM/YY),一個勾選框寫著不會扣款,只在卡上做 hold 保留房間,藍色的「Complete my booking >」按鈕,以及修改日期的「Change dates」連結。
下一頁的互動用一個沒有品牌的示意畫面代替。
- 1. 產生訂單:客人填好房型、入住、退房日期,按「continue」,reservation service 產生一筆 reservation order。
- 2. 給客人確認:唯一的
reservation_id由 globally unique ID generator 產生,放在 API 回應裡。這一步的畫面就是 Figure 9。 - 3a. 送出 reservation 1:request 帶著
reservation_id,它是 reservation 表的 primary key(Figure 6,白話:每一行獨一無二的編號)。 - 3b. 再按一次「Complete my booking」:送出 reservation 2。因為 reservation_id 是 PK,靠 key 的 unique constraint 就確保不會重複訂房。
📖 原書 idempotency key 不一定要是 reservation_id。選它是因為它本來就存在,而且很適合這個設計。
文組翻譯:餐廳先給你一張號碼牌 121,你拿號碼牌去點餐。服務生手忙腳亂收了兩次 121 號的單,廚房看到「121 號已經在做了」,就不會做兩份。
原書 · 動手玩連點兩次「Complete my booking」
三種防護,各擋得住哪一種「多按一次」?
這一步要解決的問題手抖、關掉 JavaScript、網路自動重送:哪一種防護三種都擋得住?
reservation 表
你會發現
- Client 停用按鈕:擋得住手抖,擋不住關掉 JavaScript,也擋不住網路重送(app 自己再送一次,跟按鈕無關)
- reservation_id 當 PK:三種情況都只有一筆,因為檢查發生在資料庫
- 依 idempotent 的定義,第二次應該回同一個結果(訂單 121 已成立),而不是一個嚇人的錯誤
到這裡你已經會了小結 2 / 5
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
到這裡你已經會了:庫存表與「同一個人按兩次」
- 簿子不記「哪一間」,記「每晚、每種房型還剩幾間」:inventory table。住三晚就改三行。
- 同一間房意外被訂兩次叫 double booking;飯店故意多賣 10% 叫 overbooking,是需求。
- 同一人按兩次:先發一張號碼(idempotency key),放在資料庫的 PK 上,按幾次都只算一次。
下一階要解決的問題
不同的人同時搶最後一間,每個人的號碼都不一樣,號碼擋不住。兩個櫃台同時看簿子,怎麼辦?
延伸基礎第 7 階 · race condition懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
B 晚 2 秒才看簿子,為什麼還是會超賣?
① 先想像
回到第 2 頁的兩個櫃台。從「看一眼簿子」到「寫上客人」要 3 秒,因為要轉身問客人。
你猜猜看:A 先看到「剩 1 間」,B 晚 2 秒才看。會超賣嗎?
B 看到的還是「剩 1 間」。只要晚不到 3 秒,兩個人都會說「幫您訂好了」。
③ 這叫做 race condition、isolation
race condition:「看」和「寫」之間被別人插進來。isolation:每個 transaction 看不到別人還沒 commit 的改動,像各看各的影本。race condition 的完整版:04 章
④ 跟這章的關係
原書 Figure 11 就是這件事(下一頁)。原書說,解法「通常需要某種 locking 機制」。
② 動手玩:兩個櫃台的時間軸
原書 Step 3情境 2:很多人搶最後一間 · Figure 11
兩個 transaction 都看到「剩 1 間」,都訂成功了
這一步要解決的問題不同的人同時搶最後一間,會發生什麼事?
📖 原書 假設資料庫的 isolation level 不是 serializable。飯店有 100 間,已訂 99 間。User 1 的執行叫 transaction 1、User 2 的叫 transaction 2:
原書:解決這個問題「通常需要某種 locking 機制」。接下來看三種:pessimistic locking、optimistic locking、database constraints。
白話:isolation level=transaction 之間互相看得到多少(第 25 頁);serializable=最嚴格的一級,效果像一次只准一個人用簿子。
原書 Step 3訂房的 SQL pseudo-code · 三種解法
原書的 SQL:先檢查庫存,再訂房
這一步要解決的問題原書的訂房 SQL 長什麼樣?漏洞在哪一行?
# step 1: check room inventory
SELECT date, total_inventory, total_reserved
FROM room_type_inventory
WHERE room_type_id = ${roomTypeId} AND hotel_id = ${hotelId}
AND date between ${startDate} and ${endDate}
# For every entry returned from step 1
if((total_reserved + ${numberOfRoomsToReserve}) > 110% * total_inventory) {
Rollback
}
# step 2: reserve rooms
UPDATE room_type_inventory
SET total_reserved = total_reserved + ${numberOfRoomsToReserve}
WHERE room_type_id = ${roomTypeId}
AND date between ${startDate} and ${endDate}
Commit
📖 原書 SQL 分兩部分:檢查房間庫存、預訂房間。照原書照錄。
文組翻譯
step 1 是「看一眼簿子」,中間的 if 是「心裡想:還夠」,step 2 是「寫上去」。三個動作之間,別的櫃台可以插進來。這就是第 2 頁的「兩個動作」模式。
白話:SQL=跟資料庫說話的語言;SELECT=讀,UPDATE=改;Rollback/Commit=全部撤銷/全部確定(第 8 頁)。
📖 原書 三種解法
| 做法 | 一句話 | 頁 |
|---|---|---|
| Option 1 · Pessimistic locking | 一開始就把列鎖住,別人排隊 | 29 |
| Option 2 · Optimistic locking | 不鎖,寫回時檢查版本號 | 31 |
| Option 3 · Database constraints | 讓資料庫拒絕「訂超過庫存」的結果 | 33 |
注意 step 2 的 UPDATE 的 WHERE 只有房型和日期,沒有任何庫存條件。Triton 的解法只改這一個地方(第 46 頁)。
延伸基礎第 8 階 · pessimistic lock懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
先把簿子抱走,別人站著等
① 先想像
A 櫃台把簿子抱在懷裡,想清楚、寫完才放回去。B 想看簿子,只能站著等。
你猜猜看:A 抱著簿子 10 秒。後面排了 5 位櫃台,每人也都抱 10 秒。第 5 位要等多久?
A 的 10 秒,加上前面 4 位各 10 秒,共 50 秒。抱越久、排越長,後面越慘。
③ 這叫做 lock、pessimistic lock
lock:鎖,一次只准一個人改。pessimistic lock:先假設一定會撞,所以先鎖住再看。lock 的完整版:01 章
④ 跟這章的關係
原書的 Option 1。SELECT … FOR UPDATE 就是「抱走簿子」(下一頁)。
② 動手玩:排隊等簿子
原書 Step 3Option 1 · Pessimistic locking · Figure 12
SELECT … FOR UPDATE:先鎖住,別人等你 commit
這一步要解決的問題先把那幾列鎖住、別人排隊,行不行?
📖 原書 Pessimistic locking(pessimistic concurrency control)在使用者開始更新一筆紀錄時就把它鎖住,其他人要等第一個人放鎖(commit)。MySQL 的 SELECT ... FOR UPDATE 會鎖住查詢回傳的列;transaction 2 的 SELECT 要等 transaction 1 結束,那時 total_reserved 已經是 100,User 2 訂不到。
優點
- 防止應用程式更新正在被改、或已經被改過的資料
- 容易實作,把更新序列化來避免衝突。資料競爭激烈時很有用
缺點
- 鎖住多個資源時可能 deadlock,要寫出不會 deadlock 的程式不容易
- 不 scalable:transaction 鎖太久,別人都碰不到資源,對資料庫效能影響很大,尤其 transaction 很長或牽涉很多實體時
白話:deadlock=兩人各抱一本簿子、都在等對方那本,永遠等下去。
📖 原書結論 不建議訂房系統用 pessimistic locking。
延伸基礎第 9 階 · optimistic lock懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
不抱走簿子,寫回時看頁角的版本號
① 先想像
簿子留在桌上,頁角寫著 v7。要寫的人先記下 v7;寫回時頁角還是 v7 才能寫,順手改成 v8。不是 v7,就重看一次。
你猜猜看:10 個櫃台同時記下 v7,搶最後 1 間。第一輪有幾人寫回失敗?
只有第一個寫回的人看到 v7,其他 9 人看到 v8,全部要重來。重看之後才發現賣完了。
③ 這叫做 optimistic lock、version
optimistic lock:先假設不會撞,寫回時才檢查。version:頁角的版本號,每寫一次就 +1。
④ 跟這章的關係
原書的 Option 2,原書最後選它(第 31 頁)。人少很省事,人一多就一直重來。
② 動手玩:一輪一輪搶
原書 Step 3Option 2 · Optimistic locking · Figure 13
不鎖,寫回去時檢查版本號:被別人改過就重來
這一步要解決的問題不鎖,寫回時再檢查版本號,行不行?
- 資料表加一欄
version - 使用者改一列之前,應用程式先讀那一列的版本號
- 更新時,把版本號 +1 一起寫回
- 資料庫做驗證:新的版本號要剛好比目前的大 1;驗證失敗就 abort,使用者從第 2 步再試一次
📖 原書 兩種實作:version number 和 timestamp。版本號通常比較好,因為 server 的時鐘久了會不準。樂觀鎖通常比悲觀鎖快,因為沒鎖資料庫;但並發高的時候效能會大幅下降:大家都讀到同一個剩餘數量和版本號,寫回時只有一個成功,其他人收到 version check failure 要重試;下一輪又只有一個成功……「最終結果是對的,但一再重試讓使用者體驗非常差」。
優點
- 防止應用程式改到過時的資料
- 不用鎖資料庫資源;從資料庫的角度其實沒有鎖,版本號邏輯完全由應用程式處理
- 通常用在資料競爭低的時候:衝突很少,就省下管理鎖的成本
缺點
- 資料競爭激烈時效能差
📖 原書結論 訂房的 QPS 通常不高,樂觀鎖是好選擇。
延伸基礎第 10 階 · DB constraint懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
簿子只印了 100 格,第 101 個人寫不進去
① 先想像
簿子的格子是印好的:100 間房,就只有 100 格。第 101 個人要寫,根本沒格子,簿子自己拒絕。
你猜猜看:簿子規定「已訂不能超過總數」。兩人同時寫最後一間,結果?
規則是簿子自己守的,誰來寫都要過關。但被拒絕的人前面那趟也白跑了。
③ 這叫做 database constraint、CHECK
database constraint:資料庫自己守的規則,誰寫都要過關。CHECK:寫入時檢查一個條件,不成立就拒絕。
④ 跟這章的關係
原書的 Option 3(下一頁)。跟樂觀鎖一樣擋得住超賣,但搶的人一多,很多人會被拒絕。
② 動手玩:已訂 98 間,一筆一筆寫
原書 Step 3Option 3 · Database constraints · Figure 14
加一條 CHECK:讓資料庫自己拒絕「訂超過」
這一步要解決的問題讓資料庫自己拒絕「訂超過」,行不行?
📖 原書 跟樂觀鎖很像。在 room_type_inventory 加上:
CONSTRAINT `check_room_count` CHECK((`total_inventory - total_reserved` >= 0))
同樣的例子:User 2 要訂時 total_reserved 變成 101,違反 total_inventory (100) − total_reserved (101) >= 0,transaction 被 rollback。
優點
- 容易實作
- 資料競爭很小時效果好
缺點
- 跟樂觀鎖一樣,競爭激烈時會有大量失敗:使用者看到有房,按下去卻收到「沒有空房」,很挫折
- 資料庫 constraint 不像應用程式碼那樣容易做版本控制
- 不是所有資料庫都支援 constraint,換資料庫時可能出問題
📖 原書結論 好實作、訂房競爭通常不高(QPS 低),是另一個好選擇。
到這裡你已經會了小結 3 / 5
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
到這裡你已經會了:很多人搶最後一間時,原書的三種鎖
- 「看」和「寫」中間被插隊,就是 race condition:兩個櫃台都看到「剩 1 間」。
- pessimistic lock 先把簿子抱走、別人排隊;optimistic lock 不鎖,寫回時看版本號,撞到就重來。
- DB constraint(CHECK)讓簿子自己拒絕「訂超過」。原書選樂觀鎖或 CHECK,理由是 QPS 不高。
下一階要解決的問題
如果是 booking.com 的規模,一本簿子撐不住:原書要分片、加 cache,還要面對「拆成很多本帳簿」的問題。
原書 Step 3Scalability · Database sharding · Figure 15
如果是 booking.com 的規模:QPS 高 1,000 倍
這一步要解決的問題流量大 1,000 倍,一台資料庫撐不住,怎麼辦?
📖 原書 平常訂房系統的負載不高。面試官可能追問:「如果不只是一個連鎖飯店,而是 booking.com、expedia.com 這種熱門旅遊網站呢?」QPS 可能高 1,000 倍。
📖 原書 先找瓶頸:所有服務都是 stateless,加機器就能擴展;但資料庫保存所有 state,不能單純多加幾台資料庫。
白話:stateless=櫃台不記客人,換哪個櫃台都一樣(01 章);state=要記住的資料;sharding=把簿子依編號分成好幾本(01 章)。
📖 原書 Database sharding
把資料分到多個資料庫,每個只放一部分。大部分查詢都要用 hotel_id 過濾,所以依 hotel_id 分片。Figure 15 分成 16 個 shard:假設 QPS 是 30,000,分片後每個 shard 處理 30,000 / 16 = 1,875 QPS,在一台 MySQL 的負載能力之內。
hotel_id % 16(依原書內容重繪)文組翻譯:一本訂房簿太厚、櫃台排太長,就把飯店按編號分成 16 本簿子、16 個櫃台。17 號飯店 17 ÷ 16 餘 1,就去 1 號櫃台。
原書 Step 3Caching · Figure 16
把「查庫存」搬到 Redis,資料庫只做最後一關
這一步要解決的問題查庫存的讀取太多,能不能先在資料庫前面擋掉?
📖 原書 庫存資料有個特性:只有現在和未來的才有意義,客人只能訂不久之後的房。所以最好有 TTL 讓舊資料自動過期,歷史資料去另一個資料庫查。Redis 是好選擇:TTL 加上 LRU(Least Recently Used)淘汰策略,能把記憶體用到最好。
📖 原書 如果載入速度和資料庫擴展性成了問題(booking.com、expedia.com 的規模),在資料庫上面加一層 cache,把「檢查庫存」和「訂房」的邏輯搬到 cache 層。大部分不合格的 request 會被 inventory cache 擋掉,只有一小部分打到資料庫。即使 Redis 顯示有足夠庫存,資料庫端還是要再檢查一次:資料庫才是庫存的 source of truth。
📖 原書 三個元件
- Reservation service:查某飯店、房型、日期範圍的可用房數;用
total_reserved + 1訂房;客人取消時更新庫存 - Inventory cache:所有查庫存的操作都搬到 Redis,要預先填入庫存資料。
key: hotelID_roomTypeID_{date},value:那天那種房型的可用房數。讀(查庫存)比寫多一個數量級,大部分讀由 cache 回答 - Inventory DB:存庫存資料,是 source of truth
白話:cache=手邊的小抄(01 章);Redis=放在記憶體裡的共用白板(04 章);TTL=小抄的有效期限;LRU=滿了先丟最久沒用的;source of truth=正本。
原書 Step 3New challenges posed by the cache
cache 會慢一步:只要資料庫做最後檢查,就沒關係
這一步要解決的問題cache 和資料庫的數字對不上,會出事嗎?
📖 原書 加 cache 大幅提高擴展性和吞吐,但帶來新挑戰:資料庫和 cache 怎麼保持一致。訂房的 happy path 有兩個動作:
- 查庫存:在 inventory cache 上查
- 更新庫存:先更新 inventory DB,再非同步傳到 cache。可以由應用程式在寫完資料庫後更新 cache,或用 change data capture(CDC):讀資料庫的變更、套用到另一個資料系統。常見的方案是 Debezium,用 source connector 讀資料庫的變更,套用到 Redis 這類 cache
因為資料庫先更新,cache 可能沒反映最新庫存:cache 說還有空房、資料庫說沒了,或反過來。原書:「仔細想想,這個不一致其實無所謂,只要資料庫做最終的庫存驗證。」
白話:非同步=先回覆客人,之後再慢慢抄過去;CDC=資料庫一有變更就自動抄一份到別處;Debezium 是一套現成的 CDC 工具。
優點
- 資料庫負載大降
- 讀很快,從記憶體拿
缺點
- 資料庫和 cache 的一致性很難維持,要仔細想它怎麼影響使用者體驗
動手試:原書的例子
原書 Step 3Data consistency among services · Figure 17
原書其實偷偷「不 microservice」:訂單和庫存放在同一個 RDBMS
這一步要解決的問題如果每個服務都要有自己的資料庫,會發生什麼事?
📖 原書 傳統 monolithic 架構用一個共用的關聯式資料庫來確保一致性。原書的 microservice 設計選了混合做法:Reservation Service 同時處理訂房和庫存 API,讓庫存表和訂單表放在同一個關聯式資料庫。如 concurrency 那一節所說,這讓我們可以用 RDBMS 的 ACID 優雅地處理訂房流程的各種並發問題。
📖 原書 但如果面試官是 microservice purist,可能會挑戰這個混合做法:他們心中的 microservice,每個服務都有自己的資料庫(Figure 17 右邊)。
文組翻譯
左邊:三個部門共用一本帳簿,改帳時一次改完。右邊:每個部門各自一本帳簿。訂房部記了一筆,庫存部卻沒記到,就要有人追著兩本帳簿對。
延伸基礎第 11 階 · 2PC懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
婚禮上,兩個人都說「我願意」才算數
① 先想像
主持人先問新郎「你願意嗎」,再問新娘。兩人都說願意,主持人才宣布禮成;有一人說不,就全部取消。
你猜猜看:兩人都說了願意,主持人卻突然昏倒。新人能自己宣布禮成嗎?
只有主持人能喊「禮成」或「取消」。大家只能站著等,這就是原書說的 blocking。
③ 這叫做 distributed transaction、2PC
distributed transaction:一筆交易要改兩本以上、放在不同機器的帳本。2PC(two-phase commit):先問大家「準備好了嗎」,全部說好才一起寫。
④ 跟這章的關係
原書把訂單和庫存拆成兩個資料庫後,第一個解法就是 2PC(第 41 頁)。
② 動手玩:一筆訂房,兩本帳
先選一種情況。
延伸基礎第 12 階 · Saga懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
先訂機票再訂飯店,飯店訂不到就退機票
① 先想像
自助旅行:先訂好機票,再訂飯店。飯店訂不到,就把機票退掉。每一步都是真的訂了,出錯再一步一步反過來退。
你猜猜看:機票訂好、飯店失敗,還沒退票之前,航空公司那邊看到什麼?
每一步都已經真的完成了,退票是另外再做一次。這段期間,別人看到的是「做了一半」。
③ 這叫做 Saga、compensating transaction
Saga:一連串各自完成的小 transaction。compensating transaction:出錯時反向做一次的「撤銷」。
④ 跟這章的關係
原書的第二個解法(下一頁)。原書最後兩個都不用:訂單和庫存放回同一個資料庫。
② 動手玩:哪一步失敗?
原書 Step 3Figure 18–19 · 2PC · Saga · 原書的決定
一個交易跨兩個資料庫:2PC 或 Saga,原書最後兩個都不用
這一步要解決的問題一筆訂房跨兩個資料庫,怎麼保證不會只做一半?
📖 原書 這種「純」設計帶來很多一致性問題。monolithic 裡不同操作可以包進一個 transaction 確保 ACID;microservice 裡每個服務有自己的資料庫,一個邏輯上 atomic 的操作會跨好幾個服務,不能用單一 transaction。如果 reservation 資料庫的更新失敗,就要把 inventory 資料庫已經加上去的數字 roll back。「通常只有一條 happy path,但有很多會造成不一致的失敗情況。」業界驗證過的做法:
📖 原書 Two-phase commit(2PC)
資料庫協議,保證跨多個節點的 atomic commit:全部成功或全部失敗。2PC 是 blocking protocol,一個節點故障就卡住整個進度,直到它恢復。效能不好。
📖 原書 Saga
一連串 local transaction。每個 transaction 更新後發一則 message 觸發下一步;某一步失敗,就執行 compensating transactions 撤銷前面的改動。2PC 是一次 commit 完成 ACID;Saga 由多步組成,依賴 eventual consistency。
📖 原書結論 這些機制大幅增加複雜度,值不值得由架構師決定。這題「不值得」,所以採用更務實的做法:訂房和庫存放在同一個關聯式資料庫。
原書 Step 4Wrap up · Chapter summary
原書的收尾:需求 → API 與資料模型 → 鎖 → 擴展與一致性
這一步要解決的問題原書整章走了哪幾步?
📖 原書 先收集需求、粗估規模;高階設計提出 API、第一版資料模型和架構圖。deep dive 發現訂房應該以房型為單位而不是特定房間,所以換了 schema;深入討論 race condition,提出幾個可能的解法:
- pessimistic locking
- optimistic locking
- database constraints
📖 原書 接著討論擴展的方法:database sharding 和 Redis cache。最後處理 microservice 架構的資料一致性問題,簡單走過幾個解法。
原書的結尾:「Congratulations on getting this far! Now give yourself a pat on the back. Good job!」
到這裡你已經會了小結 4 / 5
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
到這裡你已經會了:原書的完整設計
- 規模大 1,000 倍時,原書依
hotel_id分片、把查庫存搬到 Redis cache,資料庫做最後檢查。 - 拆成很多本帳簿後,一筆訂房跨兩個資料庫:2PC 全部說好才寫,但主持人一倒大家都卡住。
- Saga 一步一步做、出錯再補償。原書最後兩個都不用:訂單和庫存放同一個資料庫。
下一階要解決的問題
原書講完了。Triton 會問:跨年夜最後一間房,1000 人同時按,原書選的樂觀鎖撐得住嗎?
延伸基礎第 13 階 · atomic CAS懂的人可以跳過
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
「還有空格,才劃掉一格」:看和寫是同一個動作
① 先想像
回到第 2 頁的「一個動作」模式。櫃台不再先看再寫,而是說「還有空格就劃掉一格;沒有就告訴我客滿」。
你猜猜看:1000 個櫃台同時說「還有就劃掉一格」,只剩 1 間。幾人要重來?
檢查和劃掉是同一個動作,沒有「看到還有、寫回才發現沒了」這種事,也就不用重來。
③ 這叫做 atomic、CAS
atomic:不可分割,一口氣做完,中間沒人能插隊。CAS(check-and-set):把「檢查」和「改寫」寫在同一個動作裡。atomic CAS 的另一個例子:06 章訂最後一桌
④ 跟這章的關係
Triton 的解法就是一句 UPDATE … WHERE 還有空房(第 46 頁)。
② 動手玩:樂觀鎖 vs 一個動作
Triton 不同意059 · 高競爭時的鎖
「如果 1000 人同時按下購買……另外 999 人會 rollback 然後重來」
回頭看原書的需求
原書自己的 NFR:「旺季或大型活動時,熱門飯店可能有很多人同時想訂同一間房」。挑鎖的時候卻用全站平均 3 TPS 當理由選樂觀鎖。🔭 推論 鎖要看的是那一列有多少人同時搶,不是全站平均:跨年夜的熱門飯店,那一晚那一種房型就是一張限量球鞋。
原書這樣做會出什麼事?跨年夜 1000 人同時按最後一間,原書選的樂觀鎖會?
大家讀到同一個版本號,寫回時只有一個成功,其他 999 人收到 version check failure 重來。左邊開賣看看。
「如果 1000 人同時按下購買……只有一個會 success,另外 999 人會 rollback 然後重來」「你的系統會被大量「無效」的 transaction「佔領」,然後不管是否在搶票,都拿到 blank page-因為 DB connection 被佔光光了」🗣️ Triton 本人說 059-ecom-system design.pdf.md · 第 10 頁「搶票時的 Optimistic lock」
公平地說,Triton 並不反對樂觀鎖:「在絕大多數場景下 Optimistic lock 能提供足夠保護力」「沒有真正的用上 lock 所以不會引起 deadlock 問題」059 · 第 8 頁。他反對的是搶的場景。📝 上課筆記「如果要搶票 不要 op lock」007 · Roy 的 2026 Q1 Q&A 筆記
Triton 的解法069 · 059 · 084 · atomic check-and-set
✅ Triton 把「檢查」寫進 UPDATE 的 WHERE,看 AffectedRowCount
「Race Condition的必需條件:同一資源會被同時改動;「檢查」和「資料改動」不是在同一 Atomic operation中完成」
「善用 RDBMS的 Atomicity還有 Isolation-Update seats set user = $user where flight_no='BR855' and flight_date = '16SEP' and user = null-使用 AffectedRowCount便知道是否更新成功;關鍵字: atomic check-and-set;缺點:呃,中小型系統沒什麼缺點的。」🗣️ Triton 本人說 069-lesson1.pdf.md · 第 9、13 頁
🗣️ 同一份講義也列了另外兩種安全做法:用 Zookeeper/Redis 拿 WRITE LOCK(「萬一得到那個 WRITE LOCK的伺服器當掉,那麼便要等待 WRITE LOCK自然到期」),以及每個航班一個 Queue 單線程執行(「非常麻煩,超級麻煩!」)。069 · 第 10–12 頁
「You need a single integer remainingQuantity for every item」「Update Item set remainingQuantity -= 1 where itemID = ? and remainingQuantity > 0」🗣️ 084-order matching-system design.pdf.md · 第 20 頁「Avoid overselling」
🔭 依 Triton 原則推論 原書的 SQL 只改一個地方
BEGIN INSERT INTO reservation (...) VALUES (...); -- 059、007:先 insert UPDATE room_type_inventory SET total_reserved = total_reserved + :rooms WHERE hotel_id = :hotel AND room_type_id = :type AND date >= :start AND date < :end AND total_reserved + :rooms <= total_inventory * 1.1; -- AffectedRowCount 要等於住幾晚,否則 ROLLBACK COMMIT
沒有 SELECT、沒有版本號、沒有 CHECK 錯誤。「要等於住幾晚」是照 158 的寫法:「這樣子的atomic CAS,如果record中間有被別人改過了,其AffectedRow就不會是2」158。
🔭 補充 Figure 11 的 100、Figure 14 的 101
原書的 UPDATE 寫的是 total_reserved + N。在 MySQL InnoDB 和 PostgreSQL 的預設 isolation 下,第二個 UPDATE 會等第一個的 row lock,拿到後以最新 commit 的值再加,結果是 101(超賣),不是 Figure 11 寫的 100(lost update);PostgreSQL 的 REPEATABLE READ 則會直接報 serialization 錯誤。不管哪一種,病根都是「檢查」在 UPDATE 外面。
Triton 補充105/164 · 原書沒講的「保留 30 分鐘」
保留到期不用清理:WHERE 裡直接比時間
原書這樣做會出什麼事?客人按了訂房(pending)就去吃飯,一直沒付錢。原書的設計裡,這間房什麼時候放出來?
原書的 status 只有 pending,沒有「保留到幾點」。Triton 的戲院售票,讓保留自己過期。
🗣️ Triton 本人說 戲院售票、每張票指定座位:「系統會把這個座位給用戶X預留30分鐘。然後,用戶被帶到銀行網頁付款。如果用戶成功付款,系統便把座位的狀態從「預留中」變成「售出」。否則,30分鐘後該座位開放給所有人購票。」表 tickets,PK 是 (showtime, seat),所有座位事先 insert 好。挑座位時:
update tickets set reservation_time = now(), owner_id = 'TritonHo' where showtime = '2017-07-05 22:10' and seat = '13G' and is_sold = false and reservation_time is null or diff(now() - reservation_time) > interval'30 minutes'
「如果updated record為1,則代表用戶成功保留了這座位,否則他便被同一時間按下「選擇」的用戶Y搶走了票。」「這方法的優美:1 在用戶第一步要選擇座位時,他只需要一個update statement便好,而且使用了atomic check-and-set來防止race condition 2 除非2個用戶要選擇相同座位,否則不會發生blocking等待,也不可能有deadlock 3 reservation_time三十分鐘到期後無需後續行動,即使資料庫/web server當掉也不用做data cleanup。」105-售票系統.md(= 114 = 164 的主文)
Triton 補充 · 依原則推論080 · 164 回覆 · 120 · 套到飯店
戲院是一個座位一列;飯店是一個「數字」,怎麼套?
🗣️ Triton 本人說 080 的兩步
update seat
set status = 'reserved',
reservation_ts = now(),
user_id = :user_id
where event_id = :event_id
and seat_no = :seat_no
and (reservation_ts is null
or reservation_ts <
now() - interval '5 minute')
and status != 'sold'
update seat
set status = 'sold',
reservation_ts = null, user_id = null
where event_id = :event_id
and seat_no = :seat_no
AND user_id = :user_id
「先去佔下一個空座位,然後在 5分鐘內去 payment gateway付費 如果在 5分鐘內沒法付費,則該座位開放其他人訂購」080-nosql-intro.pdf.md · 第 12–14 頁。這版的 OR 有加括號。
🔭 推論 原書的 total_reserved 是計數器
計數器上沒有「誰、何時保留」的時間戳,過期的保留要有人把數字加回去,這就是 164 說不需要的那個 cleanup。兩條路:
- 每間「房晚」一列,像戲院座位。原書本來就預先填好兩年的庫存列,再多一個維度就是 164 的寫法
- 保留計數器,未付款的保留由 worker 加回去。Triton:「讓Race condition發生後不出現「致命錯誤」,讓系統向不致命的方向發生錯誤」069 · 第 52 頁:worker 晚跑只會少賣,不會超賣
💬 討論串回覆,作者未標示 164 底下
「如果reservation_time 改成 reservation_expired_time是不是更好? 可以支援不同的reserve window query更簡單」
「我的這寫法只能用在小戲院上啦 如果用在kktix這種大型售票, 不當掉才有鬼」
164 的主文和 105/114 完全相同,主文以下的回覆原檔沒有標發言者,依規範不當成 Triton 原話。
🗣️ 一次訂好幾晚:上鎖的順序
住三晚就是一次改三列。Triton 自己在 production 因為 Go 的 map 迭代順序不固定而 deadlock,修法是「把這個array sort by userID,讓userID比較小的用戶首先改動」120。對一句 update 同時改兩列,他說「到底是id=1先拿到lock還是id=2先拿到lock???要看不同的DB的底層實作」「但是,當你row-lock時間越短,觸發deadlock可能性就越低囉」158。
🔭 多晚、多房型的訂單,固定照 (room_type_id, date) 排序後再改。
Triton 不同意059 · 084 · 109 · 鎖要握多久
「別把第三方系統行動包在 TX 內」
原書這樣做會出什麼事?把呼叫金流包在訂房的 transaction 裡,金流卡 10 秒才回應:
金流在 transaction 裡,熱門那一列的鎖就要握到金流回來。就像第 28 頁抱著簿子去講電話。
「你家公司沒有跟金流系統結拜好兄弟-他們系統死了,別被拉扯一起死好嗎(台灣叫抓交替?)」「最要命的不是對方系統掛了 而是卡住 10秒才回應」「即使對方系統正常,response time 就當 30ms 好了 這樣子,熱門商品的 product object 就會被你的 TX 佔用額外 30ms」🗣️ Triton 本人說 059 · 第 12 頁
Begin DB transaction
//檢查用戶是否合資格購買商品
Insert into purchase_order with payment_id = null
Update product set remaining_stock -= 1
where id = ? and remaining_stock >= 1
If AffectedRowCount() == 0 return SoldOutError and Rollback
Commit DB transaction
Create payment object in Payment Gateway, and wait for payment_id
Begin DB transaction
Update purchase_order Set payment_id = ?payment_id
Commit DB transaction
🗣️ 059 第 13 頁「理想的流程」。084 第 20 頁:「Such update MUST BEFORE payment Otherwise tiny delay can cause massive overselling」。📝「因為 insert 需要更多時間 所以先放在前⾯」「所以update stock佔⽤的時間不是begin tx到commit tx的時間嗎,⽽是update statement到commit tx的時間嗎? A 對」007 · Roy 筆記的 Q&A;同檔後半貼了 ChatGPT 的長篇解說,不引用
動手試:一個訂房 transaction,熱門那一列被鎖多久?
文組翻譯,Triton 自己的比喻:「如果廁所是「稀有資源」……進廁所前請預先鬆開褲子 進了廁格後就趕快拉出來 嚴禁在廁所內玩手機 / 看報紙 拉好了就立即穿好衣物出來」059 · 第 5 頁。熱門那一列就是廁格,金流就是在廁所裡滑手機。
Triton 同意+補充059 · 015 · 126 · 庫存要獨立一張表
✅ room_type_inventory 就是 Triton 的「老手」schema,還差兩個設定
🗣️ Triton 本人說 059 第 14 頁 Database schema
| 程度 | schema |
|---|---|
| 新手/走火入魔的中手 | Product(without remaining_count column) |
| 中手 | Product(with remaining count column) |
| 老手 | Product(without remaining_count column)+ Product_stock (product_id, total_count, remaining_count) PK: product_id, FK to Product |
🔭 原書把庫存從 hotel/room 拆出來放進 room_type_inventory,正是「老手」的拆法:常被讀的商品資料和常被改的庫存分開。📝「product 和 product_stck 拆開 product 就可以 CDN」007
🗣️ 059 第 15 頁 Database tuning
- 「把 product_stock 的 table fill_factor 改低(postgresql default 是 90%)」
- 「用戶購買東西的 endpoint,改用獨立 db connection pool」
- 「理想的 db connection pool size:CPU_thread * (0.25 to 0.5) 絕對不是 100」
另一份講義談 heap table:「降低 fill_factor 能有效迴避 hot spot 問題」015。
動手試:跨年夜開賣,大家共用一個 connection pool
🗣️「「商品狀態」的頁面是完全地read-only的,頁面本身有設定好CDN嗎?商品餘額有做好caching嗎?」「現在搶買時段,資料庫100%忙碌於write上面,好的系統應該讓read-only traffic相對上不受影響的。」126
Triton 同意+補充027 · 008(筆記)· idempotency
✅ 原書的 idempotency key 放在 RDBMS 的 PK 上,Triton 會同意
🗣️ Triton 本人說 POST 本來就不 idempotent
「延伸思考:在不穩定網路下,用戶建立一份資源時,卻發出了二次的 POST,怎麼辦?」「雖然原始 HTTP POST 定義是 non-idempotent,但是他沒禁止你自行解決 idempotent 問題」
「使用 API 時,連線可能在信號送達伺服器前斷線 也可能在伺服器正要傳回 API 結果時斷線 更可能客戶端以為斷線,卻早已成功傳送資訊」
027-RESTful API Design-tw-2.1.pdf.md · HTTP method-POST、淺談網路的不穩定性
🗣️ 為什麼 total_reserved + 1 需要 key
「是否 idempotent 是看你怎做改動 這是 idempotent 的 PATCH-SET Age = 31 這不是 idempotent 的 PATCH-SET Age = Age + 1」027
🔭 訂房是 total_reserved = total_reserved + N,標準的「Age + 1」。重送一次就多扣一次庫存,所以一定要有一個唯一的 key 讓第二次變成「什麼都不做」。
📝 上課筆記 Roy 的 Notion:Restful API
「POST 要去 必避免重複⾒兩次 create uuid pre-request 檢查 把 (req.body + url) hash 存到 redis ttl 5min 把 redis response 丟回去 不⽤⽤ DB去做 update」「idempotence (created_ts or updated_ts 應⽤)」
008-…喵_Restful_API.pdf.md(Owner Roy Lee;032 是同一份的文字版)
🔭 推論 Redis 5 分鐘 vs 原書的 PK
筆記裡的 Redis 做法適合一般的 POST:省一次 DB、5 分鐘後自動消失。訂單不一樣,它是錢:Triton「主要還是一句:不能不見的data,我一定存到RDBMS」106。原書把 reservation_id 當 reservation 表的 PK,重複的保證跟訂單本身同生共死,Redis 掛了也不會重複訂房。
原書說 client 端停用按鈕「不太可靠」,Triton 的 027 也一再強調「任何可以錯的東西,都有機會出錯」。
Triton 不同意(情境差異)126 · 051 · 029 · Redis 庫存快取
cache 給頁面看可以;每次訂房前都問同一個 Redis key,就是 hotspot
「有人回答:以redis搶token,搶到token的人才能進購買頁面,這樣子才能保護資料庫不被瞬間高流量炸掉。」「關鍵點1:同一份的資料,如果你需要維持strong consistency,最終你的Write是沒法distributed,讓你的系統出現hotspot的。……存有這一個用作rate-limiting資料結構的redis-node肯定會成為hot-spot,最後炸掉當機。」🗣️ Triton 本人說 126-喵談 Keep it simple, stupid.md
🗣️ 讀也一樣:「如果所有的 READ都是從 Redis 拿資料-如果有一份資料是大量使用者需要的-這會變成 READ 版本的 hotspot」「Read的 hotspot,有機會能以 MVCC來解-反向思考:什麼是「即時」?-Snapshot是不會被改動的,所以能放在 local cache」051 · 第 18 頁
🗣️ 原書說 Redis 的 TTL 加 LRU 能把記憶體用到最好。Triton:「笨蛋:反正 Redis 滿了會自動把舊的 cache 丟掉,不設定 TTL也沒差囉~-沒設 TTL,Redis Cache Eviction是在 Peak hours 的,呵呵」「LRU不是萬能的……」051 · 第 19 頁
原書做對的一點:DB 是 source of truth,Redis 說有房還要再查 DB。📝「如果跟錢有關的話,千萬不要用 redis」029(無署名的 Redis 課堂筆記)。原書沒有把訂房結果只放在 Redis,這點和 Triton 一致。
原書這樣做會出什麼事?訂房前先問 Redis 的 hotelID_roomTypeID_{date}。跨年夜大家都訂同一天:
同一個 key 永遠只住在一台 Redis,加機器也分不掉,這叫 hotspot(04 章)。
🔭 依 Triton 原則推論 原書的 cache 拿來做三件事
| 原書的用途 | 依 Triton |
|---|---|
| 飯店、房間頁面(Hotel Cache) | 同意:靜態、read-only,CDN 與 cache 本來就該做(126) |
| 列表頁顯示「還有幾間」 | 可以,但用快照:允許舊幾秒,放 local cache 或 CDN(051「什麼是即時?」) |
| 訂房前先在 Redis 檢查、再到 DB 檢查 | 熱門那天的 hotelID_roomTypeID_{date} 是一個 key、住在一台 Redis:每個 request 都問它,就是 126 的 hotspot;而且 DB 本來就要再檢查一次 |
Triton 補充126 · 106 · 051 · 185 · 先算清楚,再分片
3 TPS 不需要分片;真的熱起來,分片也救不了「那一列」
原書這樣做會出什麼事?跨年夜 hotel 245 爆紅,把 16 個 shard 加到 32 個:
依 hotel_id 分片,同一間飯店永遠落在同一個 shard。加 shard 只對「很多間飯店」有用。
「不管何時,請嚴格遵守"Keep it simple, stupid"這個重要原則。另一個說法:不作死就不會死。」「如果不是要面對C10K,不建議你繼續看下去。」🗣️ Triton 本人說 126
🗣️「除非你明確知道你系統流量非常龐大,系統開發一律以 Consistency 優先」071 · 第 63 頁;「如果是小型系統,單純scale up便算了」「要RDBMS的clustering其中雷區冒險,我還不如走傳統的sharding路線」106
🗣️「如果你需要 Consistency,不管你是 RDBMS 還是 noSQL,一份資料只會存放在一個 master node內」「重點: hotspot是卡在 single thread效能,你沒法以加開機器來解決的」051 · 第 17 頁;「不管你Application層長怎樣。你最終會受限的還是單一Record其在DB層的處理上限。」185
🔭 推論 原書的 hotel_id 分片 Triton 會接受(106 的「傳統 sharding」),但順序是先 scale up、先用 CAS 把鎖縮短。真正的熱點是「跨年夜那一晚、那間飯店、那種房型」那一列,它只會在一個 shard 上。185 的建議 1「要麼把一份資料拆成數份獨立的來賣」:100 間房拆成 4 列、每列 25 間,同一列的競爭就降為四分之一。
動手試:16 個 shard,平常日 vs 跨年夜
🗣️ rate limiting 原書放在 API Gateway,Triton 補兩句:「Per-IP limiting 請找 cloudflare 之類的供應商,別自己來」「如果在 AS layer 來做,請務必放在 begin DB transaction 之前」059 · 第 16、19 頁
Triton 同意原書的結論134 · 051 · 156 · 100 · microservice
原書最後把訂單和庫存放回同一個 DB:Triton 會說「本來就該這樣」
「micro-serv的一個目的是:讓災情只局限在出事的module,而不是一個小白的while(1) bug讓全公司global outage。」「microservice是大公司用來清楚切割責任範圍的好手段……」「總結一句:microservice有太多太多壞處。如果系統不夠複雜公司不夠大,走microservice是單純玩弄自己的行為。」🗣️ Triton 本人說 134-喵談 micro-serv.md
🗣️「好主意:根據商業邏輯做垂直切割-service 獨立生存」「壞主意:根據內部架構做水平切割-用戶 → ServA → ServB → Database-ServB一旦死掉,依賴 ServB的 service會全滅」「一份工作要用上的 component 越多,它的Availability 就會越低」051 · 第 21 頁
🗣️「除非你要大型系統玩microservice,否則這種nodejs -> php -> nodejs絕對是玩弄自己的」「如果你呼叫的api不是127.0.0.1,請預想每一層的呼叫可以消耗掉5ms以上。」156
🔭 推論 原書的 Hotel、Rate、Reservation、Payment 是依商業邏輯垂直切的,Triton 的 051 會說是「好主意」那一種;但「Reservation 要即時問 Rate 才能算錢」(Figure 5)讓訂房依賴 Rate:051 說的「ServB一旦死掉,依賴 ServB的 service會全滅」。5,000 間飯店的連鎖品牌,是不是「公司夠大」,要看開發團隊的人數,不是看飯店數。
你猜猜看:訂一間房要串 4 個服務,每個 99.9% 的時間都正常。整條路正常的時間大約是?
四個都要同時正常:0.999 × 0.999 × 0.999 × 0.999 ≈ 0.996。每多串一個,就多一個會壞的地方。
動手算:訂一間房要經過幾個服務?
Triton 補充100 · 123 · 069 · 動手玩:在哪一步當機?
「如果你說不用2pc的,你可以寫論文了」
點一個步驟 = 在它做完之後當機,然後系統重開。
先選一個當機點。
🗣️ 沒有 2PC 時,先改哪一邊決定錯往哪邊:「先 (檢查+改動 )user_balance,然後改動 flight,這樣便會有可能賣多了;先 (檢查+改動 )flight,然後改動 user_balance,這樣便會有可能讓 user_balance變成負值」069 · 第 52 頁。📝「2 phase commit 代表你的 data 要 lock 在那邊。 你的 data 就沒有 avaiability。」029
原書說 2PC 會卡住、Saga 太複雜,所以都不用。但收錢的金流是另一家公司的系統,這一段還需要 2PC 嗎?
訂單和庫存可以放同一個資料庫,金流卻一定在別人的機器上。Triton:銀行、信用卡的串接本身就是 2PC 的變種。
「如果這二份data是存放在不同的machine上,而你是需要做到strong consistency的(即是說:不能扣了錢但是沒給用戶商品)那麼2pc(或是其變種)是不能避免的」「如果你在玩micro-service,不同service不共用database,一旦你有2個resource是在不同service的 那麼你的micro-service API design就一定要造出像stripe / paypal這樣子的2pc架構 很容易出錯(如果你說不用2pc的,你可以寫論文了)」「你用event-sourcing,也是避不了這堆問題的」🗣️ Triton 本人說 100-二份data是存放在不同的machine上(2pc).md
🗣️「所有銀行/信用卡/payment gateway的串接過程,其實是2pc的變種。」123 用 Passkit 串 Stripe 的例子:先建立 captured=false 的 Charge、存下 chargeId、再 capture,「不管Passkit伺服器在什麼時候當掉,Passkit用戶肯定會被收款,也只會收一次。」123-喵談 2pc.md
Triton 同意原書做對的地方 · 📅 2026 補充
RDBMS、ACID、庫存獨立一張表、同一個 DB:這些 Triton 都同意
✅ 選 RDBMS、靠 ACID
「不能不見的data,我一定存到RDBMS」106;「大家沒到amazon這種級別流量都會用postgresql / mysql 是有其原因的」100。原書選 relational 的第二個理由(ACID 讓程式簡單)就是 Triton 一直講的。
✅ 樂觀鎖用在低衝突
「optimistic lock的適用場景是low collision frequency(通常也是low update frequency)的資料保護」083;「Optimistic lock is suitable if the conflict rate is very low」089。原書的優缺點寫得完全一致,差別只在原書認為訂房「通常」是低衝突。
✅ version number 或 timestamp 都可以
原書說版本號比較好,因為時鐘會不準。Triton:「以人類為主要對象的商業系統,以秒為resolution的optimistic lock還算夠用」「誰說optimistic lock一定要用上update_ts? version number(int) 也行啊」083
✅ 先 scale up 的直覺
原書:7,300 萬列「一台資料庫就放得下」,只為 HA 做 replication。Triton:「資料量不夠大 (<100GB) 就乖乖回去用 RDBMS 就好啦」054
📅 2026 補充 CHECK constraint
原書說「不是所有資料庫都支援 constraint」。MySQL 在 8.0.16 之前會解析 CHECK 但直接忽略;8.0.16 起才真的執行。PostgreSQL 一直都會執行。原書那行 SQL 用反引號把 total_inventory - total_reserved 整個包成一個欄位名,照抄會報「欄位不存在」。
📅 2026 補充 小地方
原書兩次把 gRPC 拼成「gPRC」。原書 step 2 的 UPDATE 漏了 hotel_id,用 between 會把退房那晚也算進去;Figure 7 的 pending_pay 與內文的 pending 不一致。
到這裡你已經會了小結 5 / 5
- TPS
- transaction
- microservice
- inventory table
- double booking
- idempotency key
- race condition
- pessimistic lock
- optimistic lock
- DB constraint
- 2PC
- Saga
- atomic CAS
到這裡你已經會了:Triton 怎麼修
- 搶的時候別用樂觀鎖:把「還有沒有」寫進 UPDATE 的 WHERE(atomic CAS),看 AffectedRowCount。
- 鎖越短越好:先 INSERT、最後才 UPDATE,金流等 commit 之後再去;保留到期寫在 WHERE 裡比時間。
- 熱門那一晚只住在一台機器上:分片、Redis 都救不了那一列。先算清楚、先把 transaction 縮短。
13 階全部走完了
下一頁用一句話收尾;再下一頁是名詞小卡,給大家課後複習。
一句話記住
還有空房,就在同一個動作裡劃掉一格;
保留看時鐘,金流等劃完再去。
原書對的地方
- 以房型為單位,room_type_inventory 一晚一列
- RDBMS + ACID,DB 是 source of truth
- reservation_id 當 PK 做 idempotency
- 最後把訂單和庫存放同一個 DB
Triton 不同意/原書沒講
- 樂觀鎖在搶的時候:999 人 rollback 重來
- 先 SELECT 再 if 再 UPDATE:檢查在 UPDATE 外面
- 每個訂房 request 先問同一個 Redis key:hotspot
- pending 沒付款怎麼辦、金流放在哪:原書沒講
Triton 的做法
UPDATE … WHERE remaining >= n+ AffectedRowCount- 先 INSERT、最後才 UPDATE,鎖越短越好
- 保留到期寫在 WHERE,不需要 cleanup
- commit 之後才呼叫金流;跨系統用 Stripe 式的兩段式
本章名詞小卡課後複習用 · 每個名詞一句白話
今天出現的名詞,一句話講完
SELECT … FOR UPDATE給工程師的重點出處與標籤
引述來源(materials/core)與原書對照
Triton 本人的講義/文章
- 059-ecom-system design.pdf.md — 第 5 頁廁所比喻、第 8 頁樂觀鎖優點、第 10 頁 1000 人 999 rollback、第 12 頁別把第三方包在 TX 內、第 13 頁理想流程、第 14 頁新手/中手/老手 schema、第 15 頁 fill_factor 與獨立 pool、第 16 頁 Cloudflare、第 19 頁 rate limit 在 begin TX 之前
- 105-售票系統.md(= 114 = 164 的主文)— 30 分鐘保留、atomic check-and-set、三個優美之處;164 主文以下的回覆作者未標示,標 💬
- 069-lesson1.pdf.md 第 9–13 頁 race condition 必需條件與三種安全做法、第 52 頁錯往不致命的方向 · 080 第 12–14 頁戲院座位兩步 SQL · 084 第 18–20 頁 ticket workflow、MUST BEFORE payment
- 109/158 兩列互換的 atomic CAS、AffectedRow == 2、交易縮短、deadlock 不確定 · 120 production deadlock 與排序 · 083、089 樂觀鎖只適合低衝突、version number
- 126 KISS、redis token 的 hotspot、read-only 頁面 CDN · 051 第 17–21 頁 hotspot、local cache、TTL、microservice 垂直/水平切 · 185 單一 record 上限、拆成數份 · 106(從「主要還是一句」起)· 071 第 63 頁 Consistency 優先 · 054 <100GB 用 RDBMS
- 134 microservice 的兩個目的 · 156 每層 5ms · 100 不同機器避不了 2PC · 123 Passkit × Stripe 四個當機點 · 027 POST idempotent、PATCH、網路不穩定 · 015 fill_factor 迴避 hot spot
上課筆記(📝):007(Roy 的 2026 Q1 Q&A,只引短答;後半貼了 ChatGPT 的長篇解說與程式,不引)、008(Roy 的 Notion:Restful API)、029(無署名 Redis 筆記)。不引用:004(無法辨識的錄音轉錄)、048(Roy 的專案報告,雖然寫了 product_stock CAS)、187–195(AI 生成)。
一個可以直接問自己的問題
你的訂房 SQL 裡,「還有沒有房」的判斷,是寫在 UPDATE 的 WHERE,還是寫在應用程式的 if?金流的呼叫,是在 COMMIT 之前還是之後?
原書對照
Alex Xu & Sahn Lam, System Design Interview Vol.2 Ch.7。開場與 Step 1 需求(第 5 頁);Estimation 與 Figure 1(6);API design 與 Table 1–3(7);Data model 與 Figure 2(9);Reservation status 與 Figure 3、schema 的問題(10);High-level design 與 Figure 4–5(12–13);Improved data model 與 Figure 6(16);room_type_inventory、Table 4、儲存量、資料太大的兩個策略(17);庫存檢查 SQL、Table 5、overbooking(18);Concurrency 情境 1 與 Figure 7–10(20–23);情境 2 與 Figure 11(26);SQL pseudo-code(27);Pessimistic、Optimistic、Database constraints 與 Figure 12–14(29–33);Scalability、sharding 與 Figure 15(35);Caching 與 Figure 16、新挑戰(36–37);Data consistency 與 Figure 17–19、2PC、Saga(38–41);Wrap up 與 Chapter summary(42)。Figure 9 是 Booking.com 的 app 截圖,不重繪;其餘 19 張依原書圖說與 alt 重繪,不是原圖。
循序漸進(文組版)的頁面
學習地圖(第 3 頁);延伸基礎 13 階:TPS(4)、transaction(8)、microservice(11)、inventory table(15)、double booking(19)、idempotency key(21)、race condition(25)、pessimistic lock(28)、optimistic lock(30)、DB constraint(32)、2PC(39)、Saga(40)、atomic CAS(44);小結(14、24、34、43、57);名詞小卡(59)。海景旅館是虛構的示範情境;各延伸基礎頁的數字是示意,不是實測。