Đến nội dung chính
Sổ ôn Backend

Tìm kiếm

Database & ORMSenior23 phút đọc

Optimistic hay pessimistic locking: đo trên bài đặt vé 100 ghế

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

Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.

Optimistic hay pessimistic locking: đo trên bài đặt vé 100 ghế

1Pessimistic và optimistic

Khác nhau ở chỗ ai trả giá khi xung đột: pessimistic khoá trước nên người sau chờ; optimistic không khoá lúc đọc nên người sau thất bại và thử lại.

Pessimistic Optimistic
Cách làm SELECT ... FOR UPDATE Kiểm cột version lúc ghi
Hợp với Dòng nóng, thử lại tốn kém Ít tranh chấp, đọc nhiều
Rủi ro Deadlock, cạn pool Retry storm, từ chối oan

2Optimistic chạy bằng version

Câu ghi là một phép compare-and-swap (so sánh rồi mới đổi): chỉ ghi khi version còn bằng giá trị đã đọc. JPA chỉ cần @Version.

UPDATE flight
SET available_seats = 99, version = version + 1
WHERE id = 1 AND version = 7;
-- 1 dòng: thắng
-- 0 dòng: có người sửa trước, thử lại

3Bộ đếm ghế dùng gì

Đo 100 ghế, 400 request đồng thời: conditional update (WHERE available_seats > 0) đúng và nhanh nhất, vì kiểm tra và ghi nằm trong một câu.

Chiến lược Kết quả Thời gian
Naive đọc rồi ghi Bán 400 vé, sai 571 ms
FOR UPDATE Đúng, 0 retry 266 ms
Conditional UPDATE Đúng, 0 retry 203 ms
Optimistic, 5 lần thử 176 khách bị từ chối oan 484 ms

4Distributed lock cần fencing token

Lock Redis có TTL nên có thể hết hạn giữa chừng (GC pause, mạng chậm). version ở database là fencing token: chặn lần ghi của người đã mất lock.

flowchart TD
  A["A giữ lock Redis"] --> B["GC pause, TTL hết"]
  B --> C["B lấy lock, ghi trước"]
  C --> D["A tỉnh dậy, ghi tiếp"]
  D --> E{"Có version?"}
  E -->|"Không"| F["Bán 311 vé / 100 ghế"]
  E -->|"Có"| G["DB từ chối A, đúng 100"]

5Chống deadlock

Deadlock cần đủ bốn điều kiện Coffman; phá chờ vòng tròn là dễ nhất.

  • Khoá theo thứ tự cố định: id nhỏ trước, bất kể chiều chuyển.
  • Lấy mọi lock trong một câu: ORDER BY id FOR UPDATE.
  • Vẫn giữ vòng retry cho lỗi 1213.
  • "Trừ trước, cộng sau" là luật nghiệp vụ, không chống deadlock.

💡 Ghi nhớ

  • Pessimistic: người sau chờ. Optimistic: người sau thất bại, thử lại.

  • Bộ đếm một dòng: conditional UPDATE là mặc định.

  • Distributed lock luôn kèm version ở nơi ghi cuối.

  • synchronized chỉ khoá trong một JVM, không khoá database.

⭐ Điểm phỏng vấn

Tự trả lời trước, rồi bấm từng câu để xem đáp án.

  • Khi nào chọn optimistic?

    Contention thấp; dòng nóng thì pessimistic hoặc conditional update.

  • Vì sao cần cả lock lẫn version?

    Lock có TTL, version chặn người mất lock.

  • Vì sao không dùng timestamp làm version?

    Trùng trong cùng giây, đồng hồ có thể chạy lùi.

⚠️ Lỗi thường gặp

  • Dùng optimistic trên dòng nóng: retry storm, từ chối khách khi còn ghế.

  • Nghĩ optimistic không bao giờ deadlock: UPDATE vẫn lấy X lock tới commit.

  • Đặt retry bên trong @Transactional thay vì bọc ngoài transaction.

🛠 Tự tay làm

Tự viết phần lõi, chưa nhờ agent. Tick từng bước khi xong.

Nhiệm vụ: Cho người dùng sửa hạn mức chuyển tiền mỗi ngày (Phase 1, wallet-service) mà hai tab không ghi đè nhau: version đi qua HTTP bằng ETag và If-Match.

Tự viết: GET/PUT /accounts/{id}/limit, so version, lỗi 412/428, test · Được nhờ agent: migration cột daily_limit, DTO.

  1. Thêm @Version (nếu chưa có) và dailyLimit vào Account.
  2. Viết GET /accounts/{id}/limit trả kèm header ETag: "<version>".
  3. Viết PUT /accounts/{id}/limit bắt buộc If-Match: thiếu thì 428, version lệch thì 412.
  4. Viết test: tab A, B cùng GET; A PUT 5 000 000, B PUT 2 000 000 với cùng ETag cũ; in status và DB.
  5. Bắn 20 PUT đồng thời cùng If-Match: "0": đúng một 200.

Kết quả phải thấy

tab A GET                    -> 200 ETag "0"
tab B GET                    -> 200 ETag "0"
tab A PUT If-Match "0"       -> 200 ETag "1"
tab B PUT If-Match "0"       -> 412 account 1 is at version 1, you edited version 0
PUT without If-Match         -> 428 send If-Match with the ETag you got from GET
db: 5000000.00 v1
20 concurrent PUT If-Match "0" -> {200=1, 412=19}  db: 1000019.00 v1

Thử phá

Cho PUT chạy khi client không gửi If-Match: A, B đều 200, DB còn 2000000.00 v2, 5 000 000 của A mất mà không ai biết. Thêm: một POST /transfers giữa GET và PUT làm PUT nhận 412 dù không ai đụng hạn mức, vì số dư và hạn mức chung một version.

Agent hỏi lại bạn

  • Sao không giữ SELECT ... FOR UPDATE lúc người dùng đang sửa form?
  • Đã so version bằng tay, sao vẫn cần @Version?
  • Chuyển tiền gây 412 oan; tách version thế nào?

Cụm bài Transaction và locking chuyên sâu: 1. Transaction từ bên trong · 2. Transaction gây hại · 3. Lock trong InnoDB · 4. Optimistic, pessimistic và bài đặt vé

Khi nhiều request cùng sửa một dòng, nên khoá trước (pessimistic), phát hiện xung đột lúc ghi (optimistic), gộp kiểm tra vào câu ghi (conditional update), hay xếp hàng bằng distributed lock? Bài này đo cả bốn trên chuyến bay 100 ghế với 400 request đồng thời, để bạn chọn đúng cơ chế theo số liệu chứ không theo cảm tính. Nên đọc trước phần 3 (lock và contention) và bài transaction, isolation level và locking (retry đúng cách).

Sơ đồ tóm tắt:

flowchart TD
  A{"Mức tranh chấp?"} -->|"Thấp"| B["Optimistic: kiểm version"]
  A -->|"Dòng nóng"| C["Pessimistic: người sau chờ"]
  A -->|"Bộ đếm ghế"| D["UPDATE có điều kiện"]
  A -->|"Nhiều instance"| G["Distributed lock có TTL"]
  B --> E["Thất bại thì retry"]
  C --> F["Khoá theo thứ tự id"]
  G --> H["Kèm version làm fencing"]

1. Pessimistic và optimistic locking

Ý chính: pessimistic khoá trước khi làm nên người sau phải chờ; optimistic không khoá lúc đọc, chỉ kiểm tra lúc ghi xem có ai sửa trước chưa, nên người sau thất bại và thử lại.

  • Pessimistic (“bi quan”, giả định sẽ có xung đột): SELECT ... FOR UPDATE/FOR SHARE trong database, synchronized hay ReentrantLock trong Java.
  • Optimistic (“lạc quan”, giả định hiếm xung đột): compare-and-swap (so sánh rồi mới đổi) trên cột version.
SELECT available_seats, version FROM flight WHERE id = 1;          -- 100, version 7
UPDATE flight SET available_seats = 99, version = version + 1
WHERE id = 1 AND version = 7;                                      -- 1 dòng: thắng; 0 dòng: có người sửa trước

Với JPA chỉ cần field @Version. Hibernate tự thêm AND version = ? vào UPDATE và ném OptimisticLockException khi 0 dòng bị ảnh hưởng (Spring dịch thành ObjectOptimisticLockingFailureException).

Vì sao không dùng timestamp làm version

Slide cũng nhắc: lock của database khác lock của ngôn ngữ lập trình. synchronized chỉ có tác dụng trong một JVM; hai instance sau load balancer là hai lock độc lập, race condition quay lại.

2. Các best practice, giải thích từng ý

Ý chính: khoá ít nhất, ngắn nhất, qua khoá chính; dùng optimistic khi ít tranh chấp; khi có distributed lock thì vẫn giữ version ở database làm lớp chặn cuối.

  • Trừ trước, cộng sau. Trong chuyển tiền, bước trừ có điều kiện (amount >= x) chạy đầu: không đủ tiền thì dừng trước khi chạm tài khoản nhận, ít lock bị giữ vô ích, và tiền không “xuất hiện” ở B trước khi rời A.
  • Khoá qua khoá chính. Phần 3 đo được: so sánh bằng trên khoá chính chỉ tạo một record lock ở cả RR và RC.
  • Tránh UPDATE lọc bằng index phụ không unique. Nó tạo hai bộ khoá và gap lock (khoá cả khoảng trống giữa các giá trị, phần 3). Cách hay dùng: tìm khoá chính bằng SELECT thường, rồi UPDATE ... WHERE id IN (...) và lặp lại điều kiện nghiệp vụ trong WHERE, vì dữ liệu có thể đổi giữa hai bước. Đây là tối ưu cho bảng nóng, không phải luật cấm.
  • Kiểm tra lock thật. Trước khi đưa câu lệnh vào luồng nóng, chạy nó trong transaction và đọc data_locks.
  • Ưu tiên optimistic khi contention thấp (sửa hồ sơ, sửa đơn chưa thanh toán).
  • Kết hợp distributed lock + optimistic. Lock (ví dụ Redis) xếp hàng request trước khi chạm database và bảo vệ cả việc ngoài DB. Nó có thể hết hạn giữa chừng (GC pause, TTL ngắn, mạng chậm), nên version làm fencing token: chặn lần ghi của người đã mất lock. Bài tập đo đúng kịch bản này; bài review distributed lock bằng Redis phân tích cách cài Redis lock.

Bài tập

Bài 1: Đặt vé máy bay với nhiều cơ chế khoá

Đề (diễn đạt lại): cài chức năng đặt vé gồm hai bước: tạo booking và giảm số ghế còn lại. Bản cơ bản dùng pessimistic locking trong database; bản nâng cao kết hợp optimistic locking (version) với distributed lock.

Thiết lập: 7 chiến lược trên cùng harness: chuyến bay 100 ghế, 400 request đặt 1 ghế, 32 thread, mỗi thread một connection; MySQL 8.4.11 và Redis 7 trong Docker, Java 21 + JDBC. Bất biến kiểm tra cuối: số booking + ghế còn lại = 100 và ghế còn lại >= 0.

Kết quả một lần chạy (số dao động giữa các lần, xu hướng ổn định):

Chiến lược Booking Ghế còn Bất biến Hết vé Bỏ cuộc Retry Thời gian
1. Naive đọc rồi ghi 400 87 SAI 0 0 0 571 ms
2. Pessimistic FOR UPDATE 100 0 đúng 300 0 0 266 ms
3. Conditional UPDATE 100 0 đúng 300 0 0 203 ms
4. Optimistic (5 lần thử) 100 0 đúng 124 176 1.028 484 ms
5. Redis lock + optimistic 100 0 đúng 300 0 0 472 ms
6. Redis TTL 5 ms, không version 311 0 SAI 89 0 0 1.997 ms
7. Redis TTL 5 ms + version 100 0 đúng 89 211 1.257 2.351 ms

Ba điều đáng nhớ: naive bán 400 vé cho 100 ghế, optimistic từ chối oan 176 khách, và khi lock hết hạn giữa chừng (6, 7) chỉ version giữ được bất biến.

Lời giải Bài 1: code JDBC của các chiến lược và phân tích từng dòng kết quả
// 2. Pessimistic: khoá dòng flight trong lúc quyết định
static Outcome pessimistic(Connection c, long flightId, long userId) throws SQLException {
    c.setAutoCommit(false);
    try {
        int available = queryInt(c, "SELECT available_seats FROM flight WHERE id = ? FOR UPDATE", flightId);
        if (available <= 0) { c.rollback(); return Outcome.SOLD_OUT; }
        update(c, "UPDATE flight SET available_seats = available_seats - 1 WHERE id = ?", flightId);
        update(c, "INSERT INTO booking(flight_id, user_id) VALUES (?, ?)", flightId, userId);
        c.commit();
        return Outcome.BOOKED;
    } catch (SQLException e) { c.rollback(); throw e; }
}

// 4. Optimistic: so version khi ghi, thử lại có giới hạn
static Outcome optimistic(Connection c, long flightId, long userId, int maxAttempts, long workMillis)
        throws SQLException, InterruptedException {
    c.setAutoCommit(false);
    for (int attempt = 1; attempt <= maxAttempts; attempt++) {
        try {
            int[] row = queryTwoInts(c, "SELECT available_seats, version FROM flight WHERE id = ?", flightId);
            int available = row[0], version = row[1];
            if (available <= 0) { c.rollback(); return Outcome.SOLD_OUT; }
            if (workMillis > 0) Thread.sleep(workMillis);          // tính giá, gọi dịch vụ chậm...
            int rows = update(c,
                "UPDATE flight SET available_seats = ?, version = version + 1 WHERE id = ? AND version = ?",
                available - 1, flightId, version);
            if (rows == 1) {
                update(c, "INSERT INTO booking(flight_id, user_id) VALUES (?, ?)", flightId, userId);
                c.commit();
                return Outcome.BOOKED;
            }
            c.rollback();                                           // có người thắng trước: đọc lại
            Thread.sleep(ThreadLocalRandom.current().nextLong(1, 5L * attempt));
        } catch (SQLException e) { c.rollback(); throw e; }
    }
    return Outcome.GAVE_UP;
}

// 5. Distributed lock (Redis) bọc ngoài, version làm fencing token
static Outcome lockedOptimistic(Connection c, Redis redis, long flightId, long userId,
                                long ttlMillis, long workMillis) throws Exception {
    String key = "lock:flight:" + flightId, token = UUID.randomUUID().toString();
    long deadline = System.currentTimeMillis() + 5_000;
    while (!redis.setNxPx(key, token, ttlMillis)) {                 // SET key token NX PX ttl
        if (System.currentTimeMillis() > deadline) return Outcome.GAVE_UP;
        Thread.sleep(ThreadLocalRandom.current().nextLong(1, 4));
    }
    try {
        return optimistic(c, flightId, userId, 5, workMillis);
    } finally {
        redis.releaseIfOwner(key, token);   // Lua: chỉ DEL nếu value vẫn là token của mình
    }
}

Các chiến lược còn lại:

  • (1) naive: đọc rồi ghi available_seats = <giá trị đã đọc> - 1.
  • (3) conditional: UPDATE flight SET available_seats = available_seats - 1 WHERE id = ? AND available_seats > 0, rồi xem affected rows.
  • (6) Redis lock TTL 5 ms nhưng phần việc mất 10 ms, không kiểm version. (7) như (6) nhưng có version.

Client Redis là một lớp RESP tối giản tự viết (SET ... NX PX và một script Lua compare-and-delete).

Phân tích từng dòng:

  • Naive bán 400 vé mà vẫn báo còn 87 ghế: vừa bán quá, vừa lost update trên bộ đếm.
  • Pessimistic đúng và đơn giản; 32 thread xếp hàng trên một dòng, nhưng mỗi lượt giữ lock rất ngắn.
  • Conditional update nhanh nhất vì kiểm tra và ghi nằm trong một câu, lock chỉ giữ trong lúc UPDATE + INSERT. Với bộ đếm, đây là lựa chọn mặc định.
  • Optimistic: mỗi lượt thắng kéo theo ~31 lượt thua. 176 khách bị báo “thử lại sau” khi vẫn còn ghế (chỉ 124 người nhận “hết vé” thật). Đúng như slide: optimistic cho contention thấp.
  • Redis lock + optimistic: không retry nào vì Redis đã xếp hàng trước, nhưng chậm gấp đôi conditional update và thêm một hệ thống phải vận hành. Đáng giá khi việc bên trong lock có cả thứ ngoài database (gọi hãng bay đối tác, giữ chỗ bên thứ ba).
  • 6 và 7: lock hết hạn trước khi việc xong thì hai request cùng “giữ” lock; không có version thì bán 311 vé. Có version thì database chặn: mình đếm được 324 lần một request đang giữ lock (tưởng là độc quyền) vẫn bị version từ chối.

Cùng conditional update ấy chống bán quá tồn kho trong bài giỏ hàng và đặt hàng: UPDATE ... WHERE stock >= :qty chạy trong cùng transaction tạo đơn, hết hàng thì rollback cả đơn.

Retry cho optimistic phải bọc ngoài transaction (vòng lặp gọi TransactionTemplate, hoặc @Retryable trên một bean khác bọc method @Transactional), như bài transaction và locking mục retry đã giải thích.

Bản Spring Boot 3 của pessimistic và conditional update

Viết theo Spring Data JPA, chưa chạy; logic tương đương đã chạy bằng JDBC ở trên.

public interface FlightRepository extends JpaRepository<Flight, Long> {
    @Lock(LockModeType.PESSIMISTIC_WRITE)              // SELECT ... FOR UPDATE
    @Query("select f from Flight f where f.id = :id")
    Optional<Flight> findForUpdate(@Param("id") long id);

    @Modifying
    @Query("update Flight f set f.availableSeats = f.availableSeats - 1 where f.id = :id and f.availableSeats > 0")
    int decrementIfAvailable(@Param("id") long id);    // conditional update
}

@Entity
class Flight {
    @Id Long id;
    int availableSeats;
    @Version int version;                               // optimistic: Hibernate thêm "and version = ?"
}

Bài 2: Bốn điều kiện deadlock và cách tránh đơn giản

Đề: nêu bốn điều kiện để deadlock xảy ra và suy ra một cách tránh đơn giản.

Đáp ngắn: deadlock cần đủ bốn điều kiện Coffman; phá một là đủ, và cách đơn giản nhất là khoá theo thứ tự cố định để không có chờ vòng tròn.

Lời giải Bài 2: bốn điều kiện Coffman và cách phá trong database

Bốn điều kiện: loại trừ lẫn nhau (lock chỉ một bên giữ), giữ và chờ (giữ lock này trong lúc xin lock khác), không cưỡng đoạt (không ai giật được lock khỏi tay bên kia), và chờ vòng tròn.

Điều kiện Cách phá trong database
Chờ vòng tròn Khoá theo thứ tự cố định: SELECT ... WHERE id IN (?, ?) ORDER BY id FOR UPDATE, chuyển tiền luôn khoá id nhỏ trước. Cách đơn giản nhất.
Giữ và chờ Lấy mọi lock trong một câu lệnh ngay đầu transaction, hoặc dùng conditional update một câu thay vì đọc-khoá-ghi nhiều bước
Không cưỡng đoạt Database tự làm: bộ phát hiện deadlock của InnoDB chọn một nạn nhân và rollback (lỗi 1213); NOWAIT/lock_wait_timeout cho bên chờ tự bỏ cuộc
Loại trừ lẫn nhau MVCC: đọc thường không cần lock nên không tham gia deadlock

Ví dụ đặt vé nối chuyến (hai chặng là hai dòng flight): khoá cả hai bằng một câu ORDER BY id FOR UPDATE, rồi trừ ghế cả hai. Vẫn giữ vòng retry cho lỗi 1213, vì có thể có đoạn code khác khoá theo thứ tự khác. Bài race condition, volatile và deadlock áp cùng bốn điều kiện này cho lock trong Java.

Ghi nhớ

  • Giải thích được khác biệt cốt lõi giữa pessimistic và optimistic: chờ hay thất bại rồi thử lại.
  • Biết khi nào conditional update thắng cả hai, và vì sao optimistic từ chối oan trên dòng nóng.
  • Giải thích được vì sao distributed lock cần version làm fencing token, kèm con số 311 vé.
  • Biết vì sao synchronized và timestamp không đủ cho optimistic locking trên nhiều instance.
  • Nêu được bốn điều kiện deadlock và vì sao “trừ trước, cộng sau” không chống được deadlock.

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

Junior

Vì sao synchronized không giải được race condition khi ghi vào database?

Vì synchronized chỉ khoá trong một JVM, còn dữ liệu nằm ở database dùng chung cho mọi instance.

Hai instance sau load balancer có hai lock độc lập, hai request vẫn cùng đọc và cùng ghi. Phải bảo vệ ở database (câu lệnh có điều kiện, FOR UPDATE, version) hoặc bằng distributed lock.

Pessimistic và optimistic locking khác nhau ở điểm cốt lõi nào?

Pessimistic khi xung đột thì người sau chờ; optimistic khi xung đột thì người sau thất bại và thử lại.

Pessimistic khoá trước khi làm. Optimistic không khoá khi đọc, chỉ kiểm tra lúc ghi (thường bằng cột version). Một bên trả giá bằng thời gian chờ, bên kia bằng công làm lại.

Mid

Optimistic locking bằng cột version hoạt động thế nào?

Ghi kèm điều kiện version bằng giá trị đã đọc và tăng version; 0 dòng bị ảnh hưởng nghĩa là có người sửa trước.

Khi ghi: UPDATE ... SET ..., version = version + 1 WHERE id = ? AND version = ?. Một dòng là thắng; 0 dòng thì đọc lại và thử lại (hoặc báo người dùng). Với JPA chỉ cần @Version, Hibernate ném OptimisticLockException khi 0 dòng.

Vì sao không nên dùng timestamp thay cho version trong optimistic locking?

Vì timestamp có thể trùng hoặc chạy lùi, nên xung đột bị bỏ lọt.

Cột thời gian thường chỉ chính xác tới giây, hai lần cập nhật trong cùng giây cho cùng giá trị. Nếu ứng dụng tự gán thì đồng hồ các máy lệch nhau và có thể chạy lùi. Số nguyên version tăng dần không có các vấn đề này.

JPA có những LockModeType nào? OPTIMISTIC_FORCE_INCREMENT dùng khi nào?

Hai nhóm: optimistic (OPTIMISTIC, OPTIMISTIC_FORCE_INCREMENT, cần @Version) và pessimistic (PESSIMISTIC_READ, PESSIMISTIC_WRITE, PESSIMISTIC_FORCE_INCREMENT, dùng khoá của database). OPTIMISTIC_FORCE_INCREMENT tăng version kể cả khi entity không đổi.

  • OPTIMISTIC: lúc commit Hibernate kiểm tra lại version của entity đã đọc, dù không sửa nó. Dùng khi quyết định dựa trên một entity khác không được cũ.
  • OPTIMISTIC_FORCE_INCREMENT: tăng version lúc commit. Dùng cho aggregate root, ví dụ sửa một OrderLine thì tăng version của Order, để hai người sửa hai dòng khác nhau của cùng đơn vẫn xung đột.
  • PESSIMISTIC_READ thành FOR SHARE, PESSIMISTIC_WRITE thành FOR UPDATE, PESSIMISTIC_FORCE_INCREMENT khoá và tăng version ngay.
  • READ, WRITE là tên cũ của OPTIMISTIC, OPTIMISTIC_FORCE_INCREMENT. NONE là mặc định.

Thời gian chờ khoá đặt bằng hint jakarta.persistence.lock.timeout (0 nghĩa là NOWAIT).

PESSIMISTIC_WRITE có chặn câu SELECT thường của transaction khác không?

Không. Ở READ COMMITTED và REPEATABLE READ, SELECT thường của InnoDB và PostgreSQL đọc snapshot (MVCC), không xin khoá, nên vẫn chạy ngay. FOR UPDATE chỉ chặn người ghi và người đọc có khoá (FOR UPDATE, FOR SHARE).

Nhiều tài liệu ghi “PESSIMISTIC_WRITE chặn cả đọc lẫn ghi”; điều đó chỉ đúng với hệ thống khoá thuần không có MVCC. Hệ quả thực tế: luồng “đọc rồi quyết định” phải đọc bằng FOR UPDATE ở mọi nơi tham gia. Chỉ một chỗ đọc thường là nó thấy dữ liệu cũ và ghi sai. Ngoại lệ: InnoDB ở SERIALIZABLE (autocommit tắt) tự đổi SELECT thường thành FOR SHARE, nên lúc đó nó bị chặn.

Senior

Khi nào chọn optimistic, khi nào chọn pessimistic? Cho ví dụ có số liệu.

Theo mức contention: thấp thì optimistic gần như miễn phí, dòng nóng thì pessimistic hoặc tốt hơn là conditional update.

Sửa hồ sơ người dùng: optimistic. Bộ đếm ghế của một chuyến: trong thí nghiệm 400 request trên 100 ghế, optimistic tốn hơn 1.000 lần retry và 176 request bỏ cuộc khi vẫn còn ghế, còn FOR UPDATE không retry lần nào. Conditional update một câu còn tốt hơn cả hai.

Vì sao cần cả distributed lock lẫn optimistic locking, không phải một trong hai?

Lock giảm xung đột và bảo vệ việc ngoài database; version chặn lần ghi của bên đã mất lock khi lock hết hạn giữa chừng.

Distributed lock có TTL, nên GC pause hay mạng chậm có thể làm hai bên cùng tưởng mình giữ lock. Version ở database là fencing token. Thí nghiệm với TTL ngắn hơn thời gian xử lý: không có version thì bán 311 vé cho 100 ghế, có version thì đúng 100.

Quy tắc “trừ trước, cộng sau” trong chuyển tiền có chống được deadlock không?

Không. Chống deadlock cần khoá theo thứ tự cố định (id nhỏ trước), cộng vòng retry cho lỗi 1213.

Hai lệnh ngược chiều A→B và B→A cùng trừ trước sẽ khoá A và B mỗi bên một cái, rồi chờ nhau. “Trừ trước” chỉ giúp dừng sớm khi không đủ tiền và không để tiền xuất hiện ở bên nhận trước khi rời bên gửi.

Đã đặt isolation level cao rồi thì còn cần LockModeType không?

Vẫn cần. Isolation level là luật chung cho mọi câu đọc của cả transaction; LockModeType là khoá có chủ đích trên đúng những dòng bạn sắp quyết định dựa vào. Cái này không thay được cái kia.

Ví dụ: MySQL REPEATABLE READ vẫn để mất update khi hai transaction cùng đọc số dư rồi ghi, nên cần PESSIMISTIC_WRITE hoặc @Version. Ngược lại, PESSIMISTIC_WRITE trên một dòng không chặn phantom ở một truy vấn khác trong cùng transaction. Nâng cả transaction lên SERIALIZABLE thì đúng nhưng đắt (MySQL khoá mọi dòng đọc, PostgreSQL huỷ transaction để retry). Mình chọn READ COMMITTED làm nền, và khoá hoặc version đúng điểm nóng.

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
pessimistic locking /ˌpes.əˈmɪs.tɪk ˈlɑː.kɪŋ/ khoá bi quan “Pessimistic locking makes the second request wait instead of fail.”
optimistic locking /ˌɑːp.təˈmɪs.tɪk ˈlɑː.kɪŋ/ khoá lạc quan “Optimistic locking detects the conflict at write time with a version check.”
compare-and-swap /kəmˈper ən swɑːp/ so sánh rồi đổi “The version column turns the update into a compare-and-swap.”
retry storm /ˈriː.traɪ stɔːrm/ bão thử lại “On a hot row, optimistic locking caused a retry storm.”
fencing token /ˈfen.sɪŋ ˈtoʊ.kən/ mã chặn ghi của người giữ lock cũ “The version acts as a fencing token when the distributed lock expires.”
lock ordering /lɑːk ˈɔːr.dɚ.ɪŋ/ khoá theo thứ tự “Lock ordering by account id breaks the circular wait.”
lock contention /lɑːk kənˈten.ʃən/ tranh chấp khoá “High lock contention on one row caps throughput no matter how many servers we add.”
exclusive lock /ɪkˈskluː.sɪv lɑːk/ khoá ghi “SELECT FOR UPDATE takes an exclusive lock until commit.”
conditional update /kənˈdɪʃ.ən.əl ˈʌp.deɪt/ cập nhật có điều kiện “For a seat counter, a conditional update beat both locking styles.”

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.