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 階。每一階只用前面講過的東西。

  1. 1TPS每秒幾張訂房單
  2. 2transaction要嘛全做、要嘛全不做
  3. 3microservice每個部門一個櫃子
  4. 4inventory table每晚每種房型一行
  5. 5double booking一房兩賣
  6. 6idempotency key同一張號碼按兩次
  7. 7race condition看和寫中間被插隊
  8. 8pessimistic lock先把簿子抱走
  9. 9optimistic lock寫回時看版本號
  10. 10DB constraint簿子自己拒絕
  11. 112PC婚禮上兩人都說願意
  12. 12Saga訂不到就退機票
  13. 13atomic CAS還有空格才劃掉

第 1–3 階 · 一張訂房單走進系統

要回答:原書的系統分成哪幾塊?

第 4–6 階 · 庫存表與按兩次

要回答:住三晚改幾行?按兩次怎麼只算一次?

第 7–10 階 · 很多人搶最後一間

要回答:原書的三種鎖差在哪?

第 11–12 階 · 拆成很多本帳簿

要回答:一筆訂房跨兩個資料庫怎麼辦?

第 13 階 · Triton 的修法

要回答:一句 UPDATE 怎麼搞定?

全程只用一家旅館:海景旅館跨年夜(虛構)

客人送出的訂房單 = request櫃台 = app server訂房簿 = database每晚每種房型一行 = inventory table先發好的訂單號碼 = idempotency key把簿子抱走 = lock

12/31 海景雙人房,100 間、已訂 99 間:最後一間。每爬 2–4 階,有一頁「到這裡你已經會了」。

延伸基礎第 1 階 · TPS(複習 request、QPS)懂的人可以跳過

  1. TPS
  2. transaction
  3. microservice
  4. inventory table
  5. double booking
  6. idempotency key
  7. race condition
  8. pessimistic lock
  9. optimistic lock
  10. DB constraint
  11. 2PC
  12. Saga
  13. atomic CAS

一天 24 萬人按「訂房」,櫃台每秒要接幾張單?

① 先想像

跨年夜前,100 個人打開海景旅館的網頁看房,10 個人填了資料,只有 1 個人按下「訂房」。

你猜猜看:一天有 24 萬人按下「訂房」,平均每秒幾人?

③ 這叫做 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

  1. 看飯店/房間詳細頁(query)
  2. 看訂房頁:確認日期、人數、付款資訊(query)
  3. 按「book」訂房(transaction)

假設每一步只有 10% 的人走到下一步、沒有做 prefetching。從最後的 TPS 3 往回推:訂單確認頁 30、詳細頁 300。

文組翻譯:一百個人逛櫥窗,十個人走進店裡試穿,一個人結帳。收銀台每秒只有 3 個人,逛櫥窗的才是大宗。

📖 原書 Figure 1QPS distribution(依原書內容重繪;拖動左邊的滑桿,漏斗跟著變)

原書 Step 2API design · Table 1–3

三組 RESTful API:飯店、房間、訂單

這一步要解決的問題客人和飯店員工,各要透過哪些窗口送單子進來?

APIDetail
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懂的人可以跳過

  1. TPS
  2. transaction
  3. microservice
  4. inventory table
  5. double booking
  6. idempotency key
  7. race condition
  8. pessimistic lock
  9. optimistic lock
  10. DB constraint
  11. 2PC
  12. Saga
  13. atomic CAS

訂兩晚,劃到一半停電了

① 先想像

王先生訂 12/30、12/31 兩晚。櫃台劃掉 12/30 那格,正要劃 12/31,停電了。

你猜猜看:電來了,簿子上會是什麼樣子?

③ 這叫做 transaction、commit/rollback

transaction:一組動作,要嘛全做、要嘛全不做。commit/rollback:全部確定寫入/全部撤銷,回到開始前。transaction 的完整版:07 章

④ 跟這章的關係

原書選 relational database,理由之一就是它有 transaction(下一頁的 ACID)。住幾晚都在同一個 transaction 裡改。

② 動手玩:劃到一半按停電

原書 Step 2Data model · Figure 2

先看要查什麼,再選資料庫:原書選 relational

這一步要解決的問題要存哪些資料?用哪一種資料庫?

📖 原書 要支援的查詢

  1. 查看飯店的詳細資訊
  2. 給定日期範圍,找出還有空房的房型
  3. 記錄一筆訂房
  4. 查詢一筆訂房,或過去的訂房紀錄

📖 原書 為什麼選 relational database

  • 讀多寫少:逛網站的人比真正訂房的人多好幾個數量級。原書說 NoSQL 通常為寫入最佳化,RDBMS 對讀多的流程夠好
  • ACID:沒有它,很難防止負餘額、重複扣款、重複訂房;ACID 讓程式碼簡單很多,整個系統也更好推理
  • 好建模:飯店、房間、房型之間的關係清楚又穩定

白話:relational database(RDBMS)=一格一格的表,表和表用編號對起來;NoSQL=不用固定表格的資料庫;ACID=transaction 的四個保證(第 8 頁)。

規模不大,但要準備好大型活動時的流量暴增。

📖 原書 Figure 2Database schema(依原書內容重繪;表之間沒有畫連線,關係只靠同名欄位暗示)

reservation 的 status 有五種:pending、paid、refunded、canceled、rejected。原書說這是「很多應徵者最自然的建模方式」,下一頁會指出它的大問題。

原書 Step 2Reservation status · Figure 3 · 這個 schema 的大問題

訂單的五種狀態,以及「客人訂的不是 812 號房」

這一步要解決的問題一筆訂單會經過哪些狀態?客人訂的到底是哪一間房?

📖 原書 Figure 3Reservation status(依原書內容重繪;點下面的按鈕走一遍狀態)

📖 原書 這個 schema 有個大問題

這個資料模型適合 Airbnb:使用者訂房時就指定了 room_id(可能叫 listing_id)。但飯店不是這樣:客人訂的是某間飯店的一種房型,例如 standard room、king-size room、兩張 queen 床的雙人房。

房號是 check-in 時才給的,不是訂房時。所以資料模型要改,細節在 deep dive 的「Improved data model」(第 16 頁)。

文組翻譯

訂高鐵自由座,你買的是「這班車的一個位子」,不是「5 車 12A」。系統要數的是「這班車還剩幾個位子」,不是每個位子有沒有人。飯店訂房也一樣:要數的是「這一晚、這種房型,還剩幾間」。

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

  1. TPS
  2. transaction
  3. microservice
  4. inventory table
  5. double booking
  6. idempotency key
  7. race condition
  8. pessimistic lock
  9. optimistic lock
  10. DB constraint
  11. 2PC
  12. Saga
  13. atomic CAS

一個老闆一本簿子,還是每個部門一個櫃子?

① 先想像

民宿老闆一個人,用一本簿子記房間、房價、訂單。大飯店分成訂房部、定價部、收銀部,各有自己的檔案櫃。

你猜猜看:大飯店的定價部電腦當機了,訂房部還能完成訂房嗎?

③ 這叫做 monolith、microservice

monolith:一個大程式,大家共用一本帳。microservice:拆成很多小服務,各自一個資料庫,用網路互相打電話。

④ 跟這章的關係

原書的 Figure 4 用 microservice(下一頁)。到第 38 頁,原書自己又把訂單和庫存放回同一本帳。

② 動手玩:定價那一塊壞掉

0訂一間房要打幾通內線1這筆訂房寫進幾本帳

原書 Step 2High-level design · Figure 4

原書用 microservice:每個服務一個資料庫

這一步要解決的問題整個系統分成哪幾個部門?一張單子從客人手機走到哪裡?

📖 原書 Figure 4High-level design(依原書內容重繪)

📖 原書 近年 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 為了好看,省略了服務之間的箭頭

這一步要解決的問題部門之間要怎麼互相打電話?

📖 原書 Figure 5Connections between services(依原書內容重繪;alt 把左右兩半解讀成 monolithic vs microservice,內文的意思是「Figure 4 省略的兩種箭頭」,依內文說明)

文組翻譯:每個部門有自己的檔案櫃。訂房部要算錢,得打內線問定價部;總務要改資料,得一個部門一個部門去敲門。部門越多,內線電話越多。

📖 原書 左:Reservation → Rate

Reservation Service 要向 Rate Service 查房價,才能算出一筆訂單的總房費。

📖 原書 右:Hotel Management → 其他服務

員工透過 Hotel Management Service 改東西時,request 會轉給真正擁有那份資料的服務去處理,所以它應該有很多箭頭連到大多數服務。

📖 原書 服務之間怎麼溝通

production 系統的服務間通訊,常用現代、高效能的 RPC framework,例如 gRPC,好處很多。

白話:RPC=像呼叫自己的程式一樣,去叫另一台機器做事;gRPC 是 Google 做的一套。

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

  1. TPS
  2. transaction
  3. microservice
  4. inventory table
  5. double booking
  6. idempotency key
  7. race condition
  8. pessimistic lock
  9. optimistic lock
  10. DB constraint
  11. 2PC
  12. Saga
  13. atomic CAS

到這裡你已經會了:一張訂房單怎麼走進系統

下一階要解決的問題

簿子上的「剩幾間」要怎麼記?住三晚要改幾行?原書在 deep dive 一開始就改了資料表。

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

  1. TPS
  2. transaction
  3. microservice
  4. inventory table
  5. double booking
  6. idempotency key
  7. race condition
  8. pessimistic lock
  9. optimistic lock
  10. DB constraint
  11. 2PC
  12. Saga
  13. atomic CAS

簿子要記「哪一間房」,還是「這種房還剩幾間」?

① 先想像

高鐵自由座不賣「5 車 12A」,只數「這班車還剩幾個位子」。海景旅館的簿子也一樣:每晚、每種房型一行,寫總共幾間、已訂幾間。

你猜猜看:海景旅館有 2 種房型,簿子預先寫好未來 3 晚。簿子有幾行?

③ 這叫做 table/row、inventory table

table/row:資料庫裡的一張表/表上的一行。inventory table:庫存表,每晚每種房型一行,記總數和已訂數。

④ 跟這章的關係

原書的 room_type_inventory 就是這本簿子(下兩頁)。住幾晚,就要改幾行。

② 動手玩:訂一間,看改了哪幾行

0這次改了幾行

原書 Step 3Design deep dive · Improved data model · Figure 6

改成訂「房型」:API 換成 roomTypeID,庫存另開一張表

這一步要解決的問題客人訂的是房型,不是房號:API 和資料表要怎麼改?

📖 原書 Deep dive 四個主題

  1. Improved data model
  2. Concurrency issues(第 20 頁起)
  3. Scaling the system(第 35 頁起)
  4. 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。

📖 原書 Figure 6Updated schema(依原書內容重繪;新增的 room 與 room_type_inventory 用強調色標出)
  • 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_idroom_type_iddatetotal_inventorytotal_reserved
21110012021-06-0110080
21110012021-06-0210082
21110012021-06-0310086
2111001......
21110012023-05-311000
21110022021-06-0120016
22101012021-06-013023
22101012021-06-023025

📖 原書 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懂的人可以跳過

  1. TPS
  2. transaction
  3. microservice
  4. inventory table
  5. double booking
  6. idempotency key
  7. race condition
  8. pessimistic lock
  9. optimistic lock
  10. DB constraint
  11. 2PC
  12. Saga
  13. atomic CAS

同一間房,寄出了兩封確認信

① 先想像

跨年夜,兩組客人拿著同一間房的確認信到櫃台。可能是王先生網路卡、按了兩次;也可能是王先生和李小姐同時按下最後一間。

你猜猜看:飯店故意多賣 10%,賭有人會取消。這也算 double booking 嗎?

③ 這叫做 double booking、overbooking

double booking:同一個房間被意外訂了兩次。overbooking:飯店故意多賣一點,有上限。

④ 跟這章的關係

原書分兩種解:同一人按兩次(下三頁),很多人搶同一間(第 26 頁起)。

② 動手玩:三種「賣超過」

原書 Step 3Concurrency issues · 情境 1:同一個人連點兩次 · Figure 7

double booking 有兩種:同一個人點兩次、很多人搶同一間

這一步要解決的問題同一個人按了兩次「book」,怎麼只成立一筆?

📖 原書 Figure 7Two reservations are made(依原書內容重繪;alt 的兩次 INSERT 參數完全相同,第一個值 121 在 Figure 10 才說明是 reservation_id。這張是「沒有唯一約束」時的情況)

📖 原書 要解決兩個問題: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懂的人可以跳過

  1. TPS
  2. transaction
  3. microservice
  4. inventory table
  5. double booking
  6. idempotency key
  7. race condition
  8. pessimistic lock
  9. optimistic lock
  10. DB constraint
  11. 2PC
  12. Saga
  13. atomic CAS

同一張訂單號碼按兩次,只能算一次

① 先想像

網路掛號時,畫面先給你號碼 121。網路卡住,你又按了一次「送出」。櫃台看到「121 已經收過」,就不再收一次。

你猜猜看:如果 app 每按一次就產生新號碼(121、122、123),連按 3 次會成立幾筆?

③ 這叫做 idempotent、idempotency key

idempotent:同一件事做幾次,結果都一樣。idempotency key:那張先發好的號碼,按兩次也只算一次。另一個例子:10 章的重寄通知

④ 跟這章的關係

原書拿 reservation_id 當這張號碼,放在資料庫的 PK 上(下一頁)。

② 動手玩:連按「送出」

櫃台收到的單子

真正成立的訂單

0成立幾筆

原書 Step 3Idempotency key · Figure 8–10

先發一個 reservation_id,送出時帶著它,第二次就撞上唯一約束

這一步要解決的問題號碼什麼時候發?第二次送出是怎麼被擋下來的?

📖 原書 Figure 8Unique constraint(依原書內容重繪)
  • 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、網路自動重送:哪一種防護三種都擋得住?

確認訂房 · 示意畫面
King Room · 3 晚reservation_id = 121

reservation 表

你會發現

  • Client 停用按鈕:擋得住手抖,擋不住關掉 JavaScript,也擋不住網路重送(app 自己再送一次,跟按鈕無關)
  • reservation_id 當 PK:三種情況都只有一筆,因為檢查發生在資料庫
  • 依 idempotent 的定義,第二次應該回同一個結果(訂單 121 已成立),而不是一個嚇人的錯誤

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

  1. TPS
  2. transaction
  3. microservice
  4. inventory table
  5. double booking
  6. idempotency key
  7. race condition
  8. pessimistic lock
  9. optimistic lock
  10. DB constraint
  11. 2PC
  12. Saga
  13. atomic CAS

到這裡你已經會了:庫存表與「同一個人按兩次」

下一階要解決的問題

不同的人同時搶最後一間,每個人的號碼都不一樣,號碼擋不住。兩個櫃台同時看簿子,怎麼辦?

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

  1. TPS
  2. transaction
  3. microservice
  4. inventory table
  5. double booking
  6. idempotency key
  7. race condition
  8. pessimistic lock
  9. optimistic lock
  10. DB constraint
  11. 2PC
  12. Saga
  13. atomic CAS

B 晚 2 秒才看簿子,為什麼還是會超賣?

① 先想像

回到第 2 頁的兩個櫃台。從「看一眼簿子」到「寫上客人」要 3 秒,因為要轉身問客人。

你猜猜看:A 先看到「剩 1 間」,B 晚 2 秒才看。會超賣嗎?

③ 這叫做 race condition、isolation

race condition:「看」和「寫」之間被別人插進來。isolation:每個 transaction 看不到別人還沒 commit 的改動,像各看各的影本。race condition 的完整版:04 章

④ 跟這章的關係

原書 Figure 11 就是這件事(下一頁)。原書說,解法「通常需要某種 locking 機制」。

② 動手玩:兩個櫃台的時間軸

原書 Step 3情境 2:很多人搶最後一間 · Figure 11

兩個 transaction 都看到「剩 1 間」,都訂成功了

這一步要解決的問題不同的人同時搶最後一間,會發生什麼事?

📖 原書 Figure 11Race condition(依原書內容重繪)

📖 原書 假設資料庫的 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懂的人可以跳過

    1. TPS
    2. transaction
    3. microservice
    4. inventory table
    5. double booking
    6. idempotency key
    7. race condition
    8. pessimistic lock
    9. optimistic lock
    10. DB constraint
    11. 2PC
    12. Saga
    13. atomic CAS

    先把簿子抱走,別人站著等

    ① 先想像

    A 櫃台把簿子抱在懷裡,想清楚、寫完才放回去。B 想看簿子,只能站著等。

    你猜猜看:A 抱著簿子 10 秒。後面排了 5 位櫃台,每人也都抱 10 秒。第 5 位要等多久?

    ③ 這叫做 lock、pessimistic lock

    lock:鎖,一次只准一個人改。pessimistic lock:先假設一定會撞,所以先鎖住再看。lock 的完整版:01 章

    ④ 跟這章的關係

    原書的 Option 1。SELECT … FOR UPDATE 就是「抱走簿子」(下一頁)。

    ② 動手玩:排隊等簿子

    50 秒最後一位等了

    原書 Step 3Option 1 · Pessimistic locking · Figure 12

    SELECT … FOR UPDATE:先鎖住,別人等你 commit

    這一步要解決的問題先把那幾列鎖住、別人排隊,行不行?

    📖 原書 Figure 12Pessimistic locking(依原書內容重繪)

    📖 原書 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懂的人可以跳過

    1. TPS
    2. transaction
    3. microservice
    4. inventory table
    5. double booking
    6. idempotency key
    7. race condition
    8. pessimistic lock
    9. optimistic lock
    10. DB constraint
    11. 2PC
    12. Saga
    13. atomic CAS

    不抱走簿子,寫回時看頁角的版本號

    ① 先想像

    簿子留在桌上,頁角寫著 v7。要寫的人先記下 v7;寫回時頁角還是 v7 才能寫,順手改成 v8。不是 v7,就重看一次。

    你猜猜看:10 個櫃台同時記下 v7,搶最後 1 間。第一輪有幾人寫回失敗?

    ③ 這叫做 optimistic lock、version

    optimistic lock:先假設不會撞,寫回時才檢查。version:頁角的版本號,每寫一次就 +1。

    ④ 跟這章的關係

    原書的 Option 2,原書最後選它(第 31 頁)。人少很省事,人一多就一直重來。

    ② 動手玩:一輪一輪搶

    0訂到0被打回重來(累計)

    原書 Step 3Option 2 · Optimistic locking · Figure 13

    不鎖,寫回去時檢查版本號:被別人改過就重來

    這一步要解決的問題不鎖,寫回時再檢查版本號,行不行?

    📖 原書 Figure 13Optimistic locking:左 No conflict ✓,右 Conflict ✗(依原書內容重繪)
    1. 資料表加一欄 version
    2. 使用者改一列之前,應用程式先讀那一列的版本號
    3. 更新時,把版本號 +1 一起寫回
    4. 資料庫做驗證:新的版本號要剛好比目前的大 1;驗證失敗就 abort,使用者從第 2 步再試一次

    📖 原書 兩種實作:version number 和 timestamp。版本號通常比較好,因為 server 的時鐘久了會不準。樂觀鎖通常比悲觀鎖快,因為沒鎖資料庫;但並發高的時候效能會大幅下降:大家都讀到同一個剩餘數量和版本號,寫回時只有一個成功,其他人收到 version check failure 要重試;下一輪又只有一個成功……「最終結果是對的,但一再重試讓使用者體驗非常差」。

    優點

    • 防止應用程式改到過時的資料
    • 不用鎖資料庫資源;從資料庫的角度其實沒有鎖,版本號邏輯完全由應用程式處理
    • 通常用在資料競爭低的時候:衝突很少,就省下管理鎖的成本

    缺點

    • 資料競爭激烈時效能差

    📖 原書結論 訂房的 QPS 通常不高,樂觀鎖是好選擇。

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

    1. TPS
    2. transaction
    3. microservice
    4. inventory table
    5. double booking
    6. idempotency key
    7. race condition
    8. pessimistic lock
    9. optimistic lock
    10. DB constraint
    11. 2PC
    12. Saga
    13. atomic CAS

    簿子只印了 100 格,第 101 個人寫不進去

    ① 先想像

    簿子的格子是印好的:100 間房,就只有 100 格。第 101 個人要寫,根本沒格子,簿子自己拒絕。

    你猜猜看:簿子規定「已訂不能超過總數」。兩人同時寫最後一間,結果?

    ③ 這叫做 database constraint、CHECK

    database constraint:資料庫自己守的規則,誰寫都要過關。CHECK:寫入時檢查一個條件,不成立就拒絕。

    ④ 跟這章的關係

    原書的 Option 3(下一頁)。跟樂觀鎖一樣擋得住超賣,但搶的人一多,很多人會被拒絕。

    ② 動手玩:已訂 98 間,一筆一筆寫

    原書 Step 3Option 3 · Database constraints · Figure 14

    加一條 CHECK:讓資料庫自己拒絕「訂超過」

    這一步要解決的問題讓資料庫自己拒絕「訂超過」,行不行?

    📖 原書 Figure 14Database constraint(依原書內容重繪)

    📖 原書 跟樂觀鎖很像。在 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

    1. TPS
    2. transaction
    3. microservice
    4. inventory table
    5. double booking
    6. idempotency key
    7. race condition
    8. pessimistic lock
    9. optimistic lock
    10. DB constraint
    11. 2PC
    12. Saga
    13. atomic CAS

    到這裡你已經會了:很多人搶最後一間時,原書的三種鎖

    下一階要解決的問題

    如果是 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 的負載能力之內。

    📖 原書 Figure 15Database sharding: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=正本。

    📖 原書 Figure 16Caching(依原書內容重繪)

    原書 Step 3New challenges posed by the cache

    cache 會慢一步:只要資料庫做最後檢查,就沒關係

    這一步要解決的問題cache 和資料庫的數字對不上,會出事嗎?

    📖 原書 加 cache 大幅提高擴展性和吞吐,但帶來新挑戰:資料庫和 cache 怎麼保持一致。訂房的 happy path 有兩個動作:

    1. 查庫存:在 inventory cache 上查
    2. 更新庫存:先更新 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

    這一步要解決的問題如果每個服務都要有自己的資料庫,會發生什麼事?

    📖 原書 Figure 17Monolithic vs microservice(依原書內容重繪)

    📖 原書 傳統 monolithic 架構用一個共用的關聯式資料庫來確保一致性。原書的 microservice 設計選了混合做法:Reservation Service 同時處理訂房和庫存 API,讓庫存表和訂單表放在同一個關聯式資料庫。如 concurrency 那一節所說,這讓我們可以用 RDBMS 的 ACID 優雅地處理訂房流程的各種並發問題。

    📖 原書 但如果面試官是 microservice purist,可能會挑戰這個混合做法:他們心中的 microservice,每個服務都有自己的資料庫(Figure 17 右邊)。

    文組翻譯

    左邊:三個部門共用一本帳簿,改帳時一次改完。右邊:每個部門各自一本帳簿。訂房部記了一筆,庫存部卻沒記到,就要有人追著兩本帳簿對。

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

    1. TPS
    2. transaction
    3. microservice
    4. inventory table
    5. double booking
    6. idempotency key
    7. race condition
    8. pessimistic lock
    9. optimistic lock
    10. DB constraint
    11. 2PC
    12. Saga
    13. atomic CAS

    婚禮上,兩個人都說「我願意」才算數

    ① 先想像

    主持人先問新郎「你願意嗎」,再問新娘。兩人都說願意,主持人才宣布禮成;有一人說不,就全部取消。

    你猜猜看:兩人都說了願意,主持人卻突然昏倒。新人能自己宣布禮成嗎?

    ③ 這叫做 distributed transaction、2PC

    distributed transaction:一筆交易要改兩本以上、放在不同機器的帳本。2PC(two-phase commit):先問大家「準備好了嗎」,全部說好才一起寫。

    ④ 跟這章的關係

    原書把訂單和庫存拆成兩個資料庫後,第一個解法就是 2PC(第 41 頁)。

    ② 動手玩:一筆訂房,兩本帳

      先選一種情況。

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

      1. TPS
      2. transaction
      3. microservice
      4. inventory table
      5. double booking
      6. idempotency key
      7. race condition
      8. pessimistic lock
      9. optimistic lock
      10. DB constraint
      11. 2PC
      12. Saga
      13. atomic CAS

      先訂機票再訂飯店,飯店訂不到就退機票

      ① 先想像

      自助旅行:先訂好機票,再訂飯店。飯店訂不到,就把機票退掉。每一步都是真的訂了,出錯再一步一步反過來退。

      你猜猜看:機票訂好、飯店失敗,還沒退票之前,航空公司那邊看到什麼?

      ③ 這叫做 Saga、compensating transaction

      Saga:一連串各自完成的小 transaction。compensating transaction:出錯時反向做一次的「撤銷」。

      ④ 跟這章的關係

      原書的第二個解法(下一頁)。原書最後兩個都不用:訂單和庫存放回同一個資料庫。

      ② 動手玩:哪一步失敗?

      原書 Step 3Figure 18–19 · 2PC · Saga · 原書的決定

      一個交易跨兩個資料庫:2PC 或 Saga,原書最後兩個都不用

      這一步要解決的問題一筆訂房跨兩個資料庫,怎麼保證不會只做一半?

      📖 原書 Figure 18Monolithic architecture:兩個動作包在一個 transaction(依原書內容重繪)

      📖 原書 這種「純」設計帶來很多一致性問題。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!」

      📖 原書 Chapter Summary心智圖(依原書內容重繪;分支名稱照 alt)

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

      1. TPS
      2. transaction
      3. microservice
      4. inventory table
      5. double booking
      6. idempotency key
      7. race condition
      8. pessimistic lock
      9. optimistic lock
      10. DB constraint
      11. 2PC
      12. Saga
      13. atomic CAS

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

      下一階要解決的問題

      原書講完了。Triton 會問:跨年夜最後一間房,1000 人同時按,原書選的樂觀鎖撐得住嗎?

      延伸基礎第 13 階 · atomic CAS懂的人可以跳過

      1. TPS
      2. transaction
      3. microservice
      4. inventory table
      5. double booking
      6. idempotency key
      7. race condition
      8. pessimistic lock
      9. optimistic lock
      10. DB constraint
      11. 2PC
      12. Saga
      13. 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 然後重來」

      –訂到–被打回重來–送進 DB 的指令–熱門那一列被鎖住–最後一人等了

      回頭看原書的需求

      原書自己的 NFR:「旺季或大型活動時,熱門飯店可能有很多人同時想訂同一間房」。挑鎖的時候卻用全站平均 3 TPS 當理由選樂觀鎖。🔭 推論 鎖要看的是那一列有多少人同時搶,不是全站平均:跨年夜的熱門飯店,那一晚那一種房型就是一張限量球鞋。

      原書這樣做會出什麼事?跨年夜 1000 人同時按最後一間,原書選的樂觀鎖會?

      「如果 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)就去吃飯,一直沒付錢。原書的設計裡,這間房什麼時候放出來?

      🗣️ 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 秒才回應:

      「你家公司沒有跟金流系統結拜好兄弟-他們系統死了,別被拉扯一起死好嗎(台灣叫抓交替?)」「最要命的不是對方系統掛了 而是卡住 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}。跨年夜大家都訂同一天:

      🔭 依 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 個:

      「不管何時,請嚴格遵守"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% 的時間都正常。整條路正常的時間大約是?

      動手算:訂一間房要經過幾個服務?

      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 嗎?

      「如果這二份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

      1. TPS
      2. transaction
      3. microservice
      4. inventory table
      5. double booking
      6. idempotency key
      7. race condition
      8. pessimistic lock
      9. optimistic lock
      10. DB constraint
      11. 2PC
      12. Saga
      13. atomic CAS

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

      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 式的兩段式

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

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

      request送出去的一張單子
      API、RESTful系統公開的窗口/用 GET、POST、PUT、DELETE 加網址點單
      QPS、TPS每秒幾張單/每秒幾筆要寫進帳本的交易
      database(DB)存正本的帳本
      relational database(RDBMS)一格一格的表,表和表用編號對起來
      NoSQL不用固定表格的資料庫
      transaction一組動作,要嘛全做、要嘛全不做
      commit、rollback全部確定寫入/全部撤銷
      ACIDtransaction 的四個保證
      monolith一個大程式,共用一本帳
      microservice拆成很多小服務,各自一個資料庫
      CDN、API gateway、gRPC離客人最近的影本架/大門總接待/服務之間打電話的方式

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

      引述來源(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)。海景旅館是虛構的示範情境;各延伸基礎頁的數字是示意,不是實測。

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