Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Database & ORMSenior23 phút đọc

Đặt vé máy bay: giữ ghế đúng khi nhiều người cùng đặt

Ôn 15 thẻ
Trong bài này

Cụm bài Thiết kế database đặt vé máy bay: 1. Chuyến bay, ghế và overbooking · 2. Giữ ghế khi đặt đồng thời · 3. Booking, ledger và lịch sử

Phần 1 đã chọn hai mô hình ghế trống: mỗi ghế mỗi chuyến một dòng (seat_availability, trạng thái AVAILABLE/HELD/BOOKED/BLOCKED, có booking_id, held_until) hoặc một bộ đếm mỗi chuyến mỗi hạng (flight_inventory với capacity, booked và sell_limit là cột sinh từ tỉ lệ overbook). Bài này trả lời câu mà mọi buổi phỏng vấn system design về đặt chỗ đều hỏi: vài trăm người cùng đặt một chuyến, làm sao không bán trùng, không deadlock, không từ chối oan, mà vẫn nhanh? Nên đọc trước phần 1 (schema) và transaction và locking (isolation level, khoá dòng, MVCC).

Sơ đồ tóm tắt:

flowchart TD
  X[Check-then-act] -->|bán trùng| BAD[Sai]
  Q{Mô hình chỗ?} -->|bộ đếm| U["UPDATE có điều kiện + đếm dòng"]
  Q -->|tự xếp ghế| S["FOR UPDATE SKIP LOCKED"]
  Q -->|khách chọn ghế| O["ORDER BY seat_code FOR UPDATE"]
  U -.-> H["Dòng nóng: trần ≈ 1/giữ khoá"]
  S -.->|bẫy| RC["Hết chỗ? Đếm lại không khoá"]
  EX[Hết hạn giữ chỗ] --> J["Job dọn + điều kiện lười"]
  LY["Nhiều lớp: app, schema, đối soát"]

1. Vì sao “đọc rồi mới ghi” bán trùng

Ý chính: hai request cùng đọc một giá trị, cùng qua if, cùng ghi. Kết quả là bán vượt, và @Transactional không cứu được.

// SAI dưới tải đồng thời
Inventory inv = repo.find(flightId, "ECONOMY");          // booked = 175, sell_limit = 176
if (inv.booked() + qty <= inv.sellLimit()) {             // hai request cùng thấy 175 + 1 <= 176
    repo.setBooked(flightId, "ECONOMY", inv.booked() + qty);   // cả hai cùng ghi 176
}

Còn tệ hơn bán vượt: đây là lost update (bên ghi sau đè mất phần bên trước). Cả hai ghi 176, số liệu nói đã bán 176 trong khi có 177 vé.

Ba cách đúng, phần còn lại của bài là khi nào dùng cách nào:

  1. Gộp kiểm tra vào câu ghi (conditional update), rồi đếm số dòng bị ảnh hưởng.
  2. Khoá trước khi đọc (SELECT ... FOR UPDATE), có thể kèm SKIP LOCKED khi “dòng nào cũng được”.
  3. Phát hiện xung đột lúc ghi (khoá lạc quan bằng cột version), hợp khi ít tranh chấp.

2. Bộ đếm: conditional update và dòng nóng

Ý chính: với bộ đếm, một câu UPDATE có điều kiện là đủ: 0 dòng là hết chỗ, 1 dòng là đã giữ. Kiểm tra và ghi nằm trong một câu nên không có khe hở.

UPDATE flight_inventory
SET    booked = booked + :q
WHERE  flight_id = :flightId AND fare_class = :fareClass
  AND  booked + :q <= sell_limit
RETURNING booked;
-- 0 dòng: hết chỗ để bán. 1 dòng: đã giữ q chỗ.

Vì sao đúng dưới đồng thời:

  • PostgreSQL (READ COMMITTED): gặp dòng vừa bị người khác sửa, UPDATE chờ người đó xong rồi đánh giá lại WHERE trên phiên bản mới (cơ chế EvalPlanQual).
  • MySQL InnoDB: UPDATE luôn là “current read” (đọc bản mới nhất đã commit và khoá nó), kể cả ở REPEATABLE READ.

Chi tiết hai cơ chế ở transaction và locking. Bài giỏ hàng và đặt hàng dùng đúng mẫu này để trừ tồn kho từ Spring Data JPA (UPDATE ... WHERE stock >= :qty), kèm bẫy clearAutomatically của @Modifying.

2.1. Dòng nóng: bộ đếm chịu được bao nhiêu

Ý chính: mọi lượt đặt của cùng chuyến và hạng xếp hàng trên một khoá dòng tới khi commit, nên thông lượng ≈ 1 / thời gian giữ khoá.

  • Chỉ một UPDATE rồi commit ngay (vài trăm micro giây đến 1–2 ms): hàng trăm tới hàng nghìn lượt mỗi giây.
  • Gọi tính giá, dịch vụ khác hay gửi email trong transaction, giữ khoá 200 ms: còn 5 lượt mỗi giây cho cả chuyến.
Kết quả chạy thử bộ đếm với 32 client

Mọi câu SQL trong bài đã chạy thử trên PostgreSQL 16 với 6.480 chuyến và 1,17 triệu dòng ghế, kịch bản đồng thời bằng pgbench và các phiên psql song song; phần MySQL chạy thử trên MySQL 8.4.

Trên laptop, 32 client bắn 640 lượt đặt (mỗi lượt 1–3 ghế) vào một bộ đếm capacity = 168, overbook_rate = 0.05. Kết thúc với booked = 176 = sell_limit, tổng ghế của các lượt thành công đúng 176, không lượt nào vượt. Con số tps của bài thử tí hon này không có ý nghĩa cho production; điều nó chứng minh là tính đúng.

3. Hệ thống tự xếp ghế: FOR UPDATE SKIP LOCKED

Ý chính: khi khách chỉ cần “2 ghế bất kỳ”, SKIP LOCKED cho mỗi transaction bỏ qua ghế đang bị khoá và lấy ghế kế tiếp, thay vì mọi người cùng xếp hàng chờ hai ghế đầu tiên.

WITH picked AS (
  SELECT seat_code
  FROM   seat_availability
  WHERE  flight_id = :flightId AND fare_class = :fareClass AND status = 'AVAILABLE'
  ORDER  BY seat_code
  LIMIT  :n
  FOR UPDATE SKIP LOCKED
)
UPDATE seat_availability s
SET    status = 'HELD', booking_id = :bookingId, held_until = now() + interval '15 minutes'
FROM   picked
WHERE  s.flight_id = :flightId AND s.seat_code = picked.seat_code
RETURNING s.seat_code;
-- Số dòng trả về < n: ROLLBACK, không giữ nửa vời.

Ứng dụng phải đếm kết quả: ít hơn n dòng thì rollback cả transaction, vì đoàn 2 người không muốn chỉ 1 người có ghế. Chạy thử 32 client, 160 lượt mỗi lượt 2 ghế, vào khoang thương gia 12 ghế: đúng 6 lượt thành công, 154 lượt bị từ chối sạch, không ghế nào bị giữ hai lần.

EXPLAIN: vì sao partial index vẫn có dòng Filter

Kế hoạch thực thi của câu chọn ghế:

Limit
  -> LockRows
       -> Index Scan using seat_avail_free_idx on seat_availability
            Index Cond: ((flight_id = 100) AND (fare_class = 'ECONOMY'))
            Filter: (status = 'AVAILABLE')

4. Khách tự chọn ghế: khoá theo thứ tự cố định

Ý chính: khoá từng ghế theo thứ tự khách bấm sẽ deadlock khi hai khách chọn cùng cặp ghế theo thứ tự ngược nhau. Khoá tất cả ghế trong một câu, theo thứ tự cố định, rồi mới UPDATE có điều kiện.

Deadlock (khoá chết): hai transaction mỗi bên giữ một khoá và chờ khoá bên kia, không ai đi tiếp được.

T1: UPDATE ... seat_code = '10A'   -- khoá 10A
T2: UPDATE ... seat_code = '10B'   -- khoá 10B
T1: UPDATE ... seat_code = '10B'   -- chờ T2
T2: UPDATE ... seat_code = '10A'   -- chờ T1 → ERROR: deadlock detected

Chạy thử trên PostgreSQL 16: sau khoảng 1 giây (deadlock_timeout mặc định), một transaction bị huỷ, bên kia thắng. Không mất dữ liệu, nhưng người dùng thấy lỗi 500 nếu không có retry. Cách sửa:

BEGIN;
SELECT seat_code, status
FROM   seat_availability
WHERE  flight_id = :flightId AND seat_code = ANY(:seats)
ORDER  BY seat_code
FOR UPDATE;                                   -- mọi transaction khoá theo cùng thứ tự

UPDATE seat_availability
SET    status = 'HELD', booking_id = :bookingId, held_until = now() + interval '15 minutes'
WHERE  flight_id = :flightId AND seat_code = ANY(:seats) AND status = 'AVAILABLE';
-- số dòng cập nhật phải bằng số ghế yêu cầu, nếu không: ROLLBACK, báo "ghế vừa có người chọn"
COMMIT;

Chạy thử hai khách chọn {10C,10D} và {10D,10C} cùng lúc: không còn deadlock. Transaction thứ hai chờ, FOR UPDATE trả trạng thái mới nhất HELD, UPDATE được 0 dòng, ứng dụng rollback và mời khách chọn lại.

5. Hết hạn giữ chỗ

Ý chính: ghế HELD có held_until. Trả ghế bằng job định kỳ, hoặc coi ghế quá hạn là trống ngay trong câu đọc; thực tế dùng cả hai.

-- Cách 1: job định kỳ trả ghế (chạy mỗi phút)
UPDATE seat_availability
SET    status = 'AVAILABLE', booking_id = NULL, held_until = NULL
WHERE  status = 'HELD' AND held_until < now();

-- Cách 2: coi ghế giữ quá hạn là trống ngay trong câu đọc
SELECT seat_code FROM seat_availability
WHERE  flight_id = :flightId
  AND (status = 'AVAILABLE' OR (status = 'HELD' AND held_until < now()));

6. Gọi từ Spring Boot 3

Ý chính: repository chạy hai câu của mục 4 (khoá theo thứ tự, rồi UPDATE có điều kiện) và so số dòng; service ném exception để @Transactional rollback và controller trả 409 Conflict.

  • Sắp xếp và loại trùng danh sách ghế trong Java trước khi khoá.
  • Truyền mảng vào ANY(:s) cần driver PostgreSQL hỗ trợ String[] làm tham số mảng; với MySQL dùng IN (:s) với List.
  • Đoạn Java chỉ minh hoạ cách gọi, chưa được chạy (SQL bên trong thì đã chạy trực tiếp trên PostgreSQL).
Code đầy đủ: SeatHoldRepository và SeatHoldService
@Repository
@RequiredArgsConstructor
class SeatHoldRepository {
    private final JdbcClient jdbc;   // Spring Framework 6.1+

    /** Giữ đúng các ghế khách chọn; trả về false nếu có ghế đã bị người khác giữ. */
    boolean holdChosenSeats(long flightId, List<String> seats, long bookingId) {
        String[] sorted = seats.stream().sorted().distinct().toArray(String[]::new);
        jdbc.sql("""
                SELECT seat_code FROM seat_availability
                WHERE flight_id = :f AND seat_code = ANY(:s)
                ORDER BY seat_code FOR UPDATE""")
            .param("f", flightId).param("s", sorted)
            .query(String.class).list();
        int held = jdbc.sql("""
                UPDATE seat_availability
                SET status = 'HELD', booking_id = :b, held_until = now() + interval '15 minutes'
                WHERE flight_id = :f AND seat_code = ANY(:s) AND status = 'AVAILABLE'""")
            .param("b", bookingId).param("f", flightId).param("s", sorted)
            .update();
        return held == sorted.length;
    }
}

@Service
@RequiredArgsConstructor
class SeatHoldService {
    private final SeatHoldRepository seats;

    @Transactional
    public void hold(long flightId, List<String> chosen, long bookingId) {
        if (!seats.holdChosenSeats(flightId, chosen, bookingId)) {
            // ném exception để @Transactional rollback, controller map sang 409 Conflict
            throw new SeatTakenException(flightId, chosen);
        }
    }
}

Các câu SQL này nằm sau repository của context bán vé; quy tắc “giữ tối đa 10 phút, hết hạn thì nhả ghế” nằm trong aggregate booking. Cách chia bounded context (Booking, Flight, Payment) và cây package cho chính bài toán này ở DDD và cấu trúc package.

7. Khác biệt khi dùng MySQL 8

Ý chính: MySQL 8.4 có SKIP LOCKED và conditional update cũng an toàn, nhưng không có partial index và không cho chọn rồi UPDATE cùng bảng trong một câu, nên phải tách thành hai câu.

Bảng so sánh PostgreSQL 16 và MySQL 8.4
Điểm PostgreSQL 16 MySQL 8.4
SKIP LOCKED, NOWAIT Có Có (từ 8.0.1), đã chạy thử
Partial index WHERE status = 'AVAILABLE' Có Không có; dùng index ghép (flight_id, status, fare_class, seat_code)
Chọn và cập nhật trong một câu (CTE FOR UPDATE SKIP LOCKED + UPDATE) Có Không cho subquery đọc chính bảng đang UPDATE (lỗi 1093); cách đơn giản, đã chạy thử: SELECT ... FOR UPDATE SKIP LOCKED rồi UPDATE ... WHERE seat_code IN (...) trong cùng transaction
CHECK constraint Có Được thực thi từ 8.0.16 (trước đó bị bỏ qua âm thầm); đã chạy thử booked <= sell_limit bị từ chối
Cột sinh STORED Có Có
UPDATE có điều kiện dưới đồng thời Đánh giá lại WHERE trên phiên bản mới Current read, cũng an toàn; cẩn thận gap lock (khoá cả khoảng trống giữa các giá trị index) khi WHERE theo khoảng
Index cho khoá ngoại Không tự tạo InnoDB tự tạo nếu chưa có

8. Chọn kỹ thuật nào, và các lớp phòng thủ

Ý chính: mặc định dùng conditional update; khoá bi quan khi logic quá phức tạp cho WHERE; SKIP LOCKED khi “dòng nào cũng được”. Và luôn có ba lớp phòng thủ: ứng dụng, schema, đối soát.

Dùng Redis thì Redis vẫn không được là nguồn sự thật: replication bất đồng bộ nên một DECR đã trả “OK” có thể mất khi failover, và tuỳ cấu hình RDB/AOF, restart còn mất thêm vài giây dữ liệu. DB có tiếng nói cuối, Redis chỉ chắn tải; Redis mất gì trong từng trường hợp ở Redis: persistence, replication, Sentinel và Cluster.

Không lớp nào đủ một mình, vì luôn có batch job, script sửa tay hay đường code mới đi vòng qua service:

Lớp Cơ chế Chặn được
Ứng dụng Conditional update hoặc khoá theo thứ tự, so số dòng Gần như mọi trường hợp đồng thời
Schema Khoá chính (flight_id, seat_code), CHECK nối trạng thái với booking_id, CHECK (booked <= sell_limit), unique index một phần trên vé còn hiệu lực (phần 3) Bug trong code, script sửa tay
Vận hành Truy vấn đối soát định kỳ + cảnh báo Sai lệch giữa các bảng mà ràng buộc không diễn tả được

Khi thứ cần giữ là một khoảng thời gian (phòng theo đêm, phòng họp theo khung giờ), UNIQUE không diễn tả được “không chồng lấn”. PostgreSQL làm được ở tầng schema bằng exclusion constraint trên GiST (EXCLUDE USING gist (room_id WITH =, during WITH &&)), xem Các loại index ngoài B-tree.

Ví dụ truy vấn đối soát

Tìm ghế BOOKED mà không có vé còn hiệu lực (tương tự cho bộ đếm lệch so với số vé đã xuất):

SELECT sa.flight_id, sa.seat_code
FROM   seat_availability sa
LEFT JOIN ticket t ON t.flight_id = sa.flight_id AND t.seat_code = sa.seat_code
                  AND t.status IN ('ISSUED', 'USED')
WHERE  sa.status = 'BOOKED' AND t.ticket_id IS NULL
  AND  sa.flight_id IN (SELECT flight_id FROM flight WHERE departure_time > now());

Các lựa chọn này được đo cạnh nhau (naive, FOR UPDATE, conditional update, version, Redis lock có và không có fencing token) trên chuyến 100 ghế với 400 request đồng thời ở bài Optimistic hay pessimistic locking.

Bài tập

Bài 1: Chọn ghế an toàn

Đề: viết service “giữ các ghế khách chọn” sao cho không deadlock, không giữ nửa vời, và báo đúng lỗi khi ghế vừa bị người khác lấy.

Lời giải Bài 1

Xem mục 4 và 6: sắp xếp và loại trùng danh sách ghế; SELECT ... ORDER BY seat_code FOR UPDATE; UPDATE có điều kiện status = 'AVAILABLE'; so số dòng; sai thì ném exception để rollback và trả 409 Conflict. Senior thêm: retry một lần cho lỗi deadlock hoặc serialization; lock_timeout vài giây; metric số lượt 409 theo chuyến để phát hiện chuyến nóng.

Bài 2: Job trả ghế chạy trên nhiều instance

Đề: service chạy 4 pod, mỗi pod có @Scheduled trả ghế hết hạn mỗi phút. Có lúc vài chục nghìn ghế hết hạn cùng lúc (một đợt khuyến mãi bị bỏ dở). Viết câu SQL sao cho các pod không chặn nhau, mỗi lượt chạy giữ khoá ngắn, và không trả một ghế hai lần.

Lời giải Bài 2

Xử lý theo lô, mỗi lô lấy ghế bằng SKIP LOCKED để các pod chia nhau:

WITH batch AS (
  SELECT flight_id, seat_code
  FROM   seat_availability
  WHERE  status = 'HELD' AND held_until < now()
  ORDER  BY held_until
  LIMIT  1000
  FOR UPDATE SKIP LOCKED
)
UPDATE seat_availability s
SET    status = 'AVAILABLE', booking_id = NULL, held_until = NULL
FROM   batch
WHERE  s.flight_id = batch.flight_id AND s.seat_code = batch.seat_code
RETURNING s.flight_id, s.seat_code;

Lặp tới khi trả về 0 dòng, mỗi lô một transaction. Hai pod chạy cùng lúc lấy hai lô khác nhau; điều kiện status = 'HELD' được kiểm tra lại sau khi khoá nên không ghế nào bị trả hai lần. Partial index (held_until) WHERE status = 'HELD' giữ câu chọn lô rẻ.

Senior thêm: nếu dùng bộ đếm thay vì từng ghế, trả chỗ là UPDATE flight_inventory SET booked = booked - :q, phải gắn với việc chuyển booking sang EXPIRED trong cùng transaction (conditional update trên trạng thái booking) để không trừ hai lần; và không trả chỗ của booking đang có thanh toán dở dang (bài cổng thanh toán).

Bài 3: Báo “hết vé” hay “thử lại”

Đề: tự xếp ghế bằng SKIP LOCKED trả thiếu ghế. Viết câu kiểm tra để phân biệt hết thật với đang bị giữ tạm.

Lời giải Bài 3
SELECT count(*) FILTER (WHERE status = 'AVAILABLE')                       AS free_now,
       count(*) FILTER (WHERE status = 'HELD' AND held_until > now())       AS held_temporarily
FROM   seat_availability
WHERE  flight_id = :flightId AND fare_class = :fareClass;

Câu này không khoá gì (đọc snapshot), nên không bị chặn.

  • free_now >= n: ghế đang bị khoá bởi transaction chưa kết thúc, retry sau vài trăm mili giây có jitter.
  • free_now + held_temporarily >= n: có thể trống lại khi người khác bỏ dở, báo “đang có người giữ chỗ”.
  • Chỉ khi cả hai đều nhỏ hơn n mới báo hết vé.

Ghi nhớ

  • Giải thích được vì sao check-then-act bán trùng kể cả trong @Transactional, và ba cách đúng thay thế.
  • Viết được câu conditional update cho bộ đếm và nói được vì sao nó đúng trên PostgreSQL và MySQL.
  • Tính được trần thông lượng của dòng nóng từ thời gian giữ khoá, và biết đưa gì ra khỏi transaction.
  • Biết khi nào dùng SKIP LOCKED, khi nào khoá theo thứ tự cố định, và cách tránh báo hết chỗ oan.
  • Kể được ba lớp phòng thủ chống bán trùng và cách trả ghế hết hạn an toàn.

Câu hỏi phỏng vấn

Junior

Check-then-act là gì và vì sao nó sai khi đồng thời?

Là đọc trạng thái, kiểm tra trong code, rồi ghi dựa trên giá trị đã đọc; giữa lúc đọc và ghi, request khác có thể đã đổi dữ liệu.

Hai request cùng qua điều kiện và cùng ghi: bán trùng và mất cập nhật. Sửa bằng cách đưa điều kiện vào câu ghi và kiểm tra số dòng, hoặc khoá dòng trước khi đọc.

Mid

Viết câu SQL giữ chỗ cho bộ đếm sao cho đúng khi đồng thời

UPDATE flight_inventory SET booked = booked + :q WHERE flight_id = :f AND fare_class = :c AND booked + :q <= sell_limit, rồi kiểm tra số dòng: 1 là giữ được, 0 là hết.

Không SELECT trước rồi mới UPDATE (check-then-act). Đúng vì PostgreSQL đánh giá lại WHERE trên phiên bản mới sau khi chờ khoá, còn UPDATE của MySQL là current read.

SKIP LOCKED dùng khi nào, và cạm bẫy của nó?

Khi “dòng nào cũng được”: tự xếp ghế, hàng đợi công việc nhiều worker. Cạm bẫy: có thể báo hết chỗ trong khi lát nữa còn chỗ.

Mỗi transaction bỏ qua dòng đang bị khoá thay vì chờ, nên không xếp hàng trên vài dòng đầu. Nhưng nó bỏ qua cả dòng bị khoá bởi transaction sắp rollback; cần kiểm tra lại bằng câu đếm không khoá. Không dùng cho “đúng ghế 12A”.

Hai khách cùng chọn hai ghế giống nhau, làm sao không deadlock?

Khoá tất cả ghế cần giữ trong một câu với thứ tự cố định (ORDER BY seat_code FOR UPDATE), sau đó UPDATE có điều kiện status = 'AVAILABLE' và so số dòng.

Khoá lần lượt theo thứ tự khách bấm sẽ khoá chéo. Vẫn giữ retry cho lỗi deadlock vì đường code khác có thể khoá khác thứ tự.

Senior

Chuyến bay dịp Tết có vài trăm người cùng đặt. Thiết kế của bạn chịu thế nào?

Tải dồn vào một chuyến nên vấn đề là tranh chấp, không phải tổng thông lượng: giữ transaction giữ chỗ cực ngắn và đặt lock_timeout.

  • Transaction chỉ có UPDATE có điều kiện và INSERT; tính giá và gọi ngoài làm trước, tác dụng phụ qua outbox.
  • Mô hình ghế: tranh chấp rải theo ghế; tự xếp ghế dùng SKIP LOCKED.
  • Bộ đếm: trần xấp xỉ 1 chia thời gian giữ khoá; đo thấy chưa đủ thì giữ chỗ trước trên Redis có TTL rồi ghi DB, hoặc hàng đợi ảo trước trang đặt vé.
  • Đo bằng load test dồn vào đúng một chuyến, không trải đều.
Bạn sẽ đảm bảo không bao giờ bán một ghế cho hai người bằng những lớp nào?

Ba lớp: ứng dụng (UPDATE có điều kiện, so số dòng), schema (ràng buộc), vận hành (đối soát và cảnh báo). Không tin một lớp duy nhất.

  • Schema: khoá chính (flight_id, seat_code) trên bảng ghế trống, CHECK gắn trạng thái với booking_id, unique index một phần (flight_id, seat_code) trên bảng vé cho các vé còn hiệu lực.
  • Vận hành: truy vấn đối soát định kỳ tìm ghế có hai vé hoặc vé không khớp trạng thái ghế.
  • Lý do: sẽ có batch job hay script sửa tay đi vòng qua code.
Khi nào bạn chấp nhận hết hạn giữ chỗ bằng job định kỳ, khi nào cần chính xác tới giây?

Job mỗi phút đủ khi một ghế “bị giữ thêm” tối đa một phút không đáng kể; chuyến đang cháy vé hoặc giữ chỗ ngắn thì thêm điều kiện lười ở câu giữ ghế.

Job đơn giản, index gọn. Điều kiện lười “HELD nhưng held_until < now() coi như trống” giúp không từ chối oan. Dù cách nào, trước khi trả chỗ của booking chờ thanh toán phải kiểm tra không có thanh toán đang bay, nếu không khách sẽ trả tiền cho ghế đã bán cho người khác.

Vì sao UPDATE có điều kiện vẫn đúng ở READ COMMITTED, dù không có khoá trước?

Vì UPDATE tự khoá dòng nó sửa, và kiểm tra cùng ghi nằm trong một câu trên phiên bản mới nhất, nên không có khe hở giữa đọc và ghi.

  • PostgreSQL: dòng đang bị người khác sửa thì UPDATE chờ, rồi đánh giá lại WHERE trên phiên bản mới (EvalPlanQual); điều kiện không còn đúng thì bỏ qua, số dòng là 0.
  • MySQL InnoDB: UPDATE luôn đọc phiên bản mới nhất đã commit (current read) và khoá nó.
  • Ở SERIALIZABLE hay REPEATABLE READ của PostgreSQL, thay vì đánh giá lại, transaction nhận lỗi serialization và phải retry.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
check-then-act /tʃek ðen ækt/ đọc rồi mới ghi “Check-then-act in application code oversells under concurrency.”
lost update /lɔːst ˈʌp.deɪt/ mất cập nhật “Both requests wrote 176, so we oversold and lost an update.”
conditional update /kənˈdɪʃ.ən.əl ˈʌp.deɪt/ cập nhật có điều kiện “A conditional update checks and writes in one atomic statement.”
hot row /hɑːt roʊ/ dòng bị tranh chấp nhiều “A single counter per flight becomes a hot row during peak sales.”
contention /kənˈten.ʃən/ tranh chấp “The problem isn’t total throughput, it’s contention on one flight.”
row-level lock /roʊ ˈlev.əl lɑːk/ khoá mức dòng “Two customers picking different seats never block each other’s row-level locks.”
skip locked /skɪp lɑːkt/ bỏ qua dòng đang khoá “Auto-assignment uses SKIP LOCKED so requests don’t queue on the first free seats.”
deadlock /ˈded.lɑːk/ khoá chết “Locking seats in click order caused deadlocks; we now lock them in sorted order.”
lock timeout /lɑːk ˈtaɪm.aʊt/ thời gian chờ khoá tối đa “We set a lock timeout so a stuck request fails fast instead of draining the pool.”
hold expiry /hoʊld ɪkˈspaɪ.ri/ hết hạn giữ chỗ “Held seats carry an expiry, and a job releases them every minute.”
current read /ˈkɝː.ənt riːd/ đọc phiên bản mới nhất (InnoDB) “In InnoDB an UPDATE is a current read, so it sees the latest committed row.”

Ghi chép dựa trên khoá Advanced Backend (Ronin Engineer), viết lại theo cách hiểu của mình.