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

Tìm kiếm

Database & ORMSenior25 phút đọc

Database: transaction, isolation level và locking

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

Cụm bài Database: 1. Bảng và SQL cơ bản · 2. ERD, JOIN, GROUP BY · 3. Chuẩn hoá · 4. Bài tập thư viện · 5. Index và hiệu năng truy vấn · 6. Transaction và locking

Code chạy đúng với một người dùng vẫn có thể sai khi hai request chạm cùng một dòng: bán quá số hàng, mất tiền khi hai lần nạp ví chạy cùng lúc, job chạy hai lần. Đọc xong, bạn chọn được cách giữ dữ liệu đúng (update nguyên tử, khoá, version, unique constraint) và retry cho đúng; ví dụ chạy trên MySQL 8.4 (InnoDB), chỗ PostgreSQL khác có ghi chú. Nên đọc trước Index và hiệu năng truy vấn, vì InnoDB khoá bản ghi trong index, nên hiểu index mới hiểu vì sao một câu UPDATE có thể khoá cả bảng.

1. Transaction và ACID

Ý chính: transaction là một nhóm thao tác thành công hết hoặc không có gì xảy ra. InnoDB giữ bốn tính chất ACID bằng undo log, redo log, lock và MVCC.

START TRANSACTION;
UPDATE account SET balance = balance - 500000 WHERE id = 1;
UPDATE account SET balance = balance + 500000 WHERE id = 2;
INSERT INTO transfer_log (from_id, to_id, amount) VALUES (1, 2, 500000);
COMMIT;   -- hoặc ROLLBACK nếu có lỗi
Tính chất Ý nghĩa InnoDB làm thế nào
Atomicity Tất cả hoặc không gì cả Undo log lưu giá trị cũ để rollback
Consistency Luôn từ trạng thái hợp lệ sang trạng thái hợp lệ Constraint, FK, cộng logic đúng của ứng dụng
Isolation Không thấy trạng thái dở dang của nhau (tuỳ isolation level) Lock + MVCC
Durability Đã commit thì không mất khi crash Redo log (WAL, ghi log trước rồi mới ghi page dữ liệu) được fsync khi commit

2. Isolation level và các anomaly

Ý chính: isolation level quyết định transaction thấy được bao nhiêu thay đổi của người khác. Bảng chuẩn SQL chỉ nói về ba anomaly đọc; lost update và write skew mới là thứ hay làm mất tiền, và mỗi DB xử lý khác nhau.

Anomaly là hiện tượng sai khi hai transaction chạy chen nhau:

Anomaly Mô tả
Dirty read Đọc được dữ liệu transaction khác chưa commit (rồi nó rollback).
Non-repeatable read Đọc một dòng hai lần trong cùng transaction, ra hai giá trị vì người khác đã update và commit.
Phantom read Chạy cùng điều kiện hai lần, lần sau có dòng mới do người khác insert.
Lost update Hai bên cùng đọc rồi ghi dựa trên giá trị đã đọc; ghi sau đè mất ghi trước.
Write skew Hai bên đọc cùng tập dữ liệu, mỗi bên ghi vào dòng khác nhau, gộp lại phá ràng buộc (hai bác sĩ cùng xin nghỉ khi “luôn phải có ít nhất 1 người trực”).

Bốn mức theo chuẩn SQL:

Level Dirty read Non-repeatable Phantom
READ UNCOMMITTED Có thể Có thể Có thể
READ COMMITTED Không Có thể Có thể
REPEATABLE READ Không Không Có thể (theo chuẩn)
SERIALIZABLE Không Không Không

Lost update: ví dụ thật

Ý chính: đọc giá trị vào ứng dụng, tính, rồi ghi lại là mất cập nhật, kể cả ở MySQL RR. Phải để DB làm đọc-sửa-ghi, hoặc khoá, hoặc kiểm tra version.

Chạy thử trên MySQL 8.4 (RR): ví có 100, T1 cộng 10, T2 cộng 50, mỗi bên đọc trong ứng dụng rồi ghi lại.

sequenceDiagram
  participant T1
  participant DB as wallet.balance
  participant T2
  T1->>DB: SELECT balance (100)
  T2->>DB: SELECT balance (100)
  T2->>DB: UPDATE balance = 100 + 50
  T2->>DB: COMMIT (150)
  T1->>DB: UPDATE balance = 100 + 10
  T1->>DB: COMMIT (110, mất 50 của T2)

Kết quả 110 thay vì 160. Bốn cách sửa:

-- 1. Cập nhật nguyên tử: để DB tự đọc-sửa-ghi trên bản mới nhất
UPDATE wallet SET balance = balance + 10 WHERE id = 1;

-- 2. Có điều kiện nghiệp vụ: trừ kho chỉ khi còn hàng
UPDATE product SET stock = stock - 1 WHERE id = ? AND stock >= 1;
-- affected rows = 0 nghĩa là hết hàng

-- 3. Khoá bi quan (pessimistic): khoá dòng ngay khi đọc
START TRANSACTION;
SELECT balance FROM wallet WHERE id = 1 FOR UPDATE;
UPDATE wallet SET balance = ? WHERE id = 1;
COMMIT;

-- 4. Khoá lạc quan (optimistic): cột version
UPDATE wallet SET balance = ?, version = version + 1
WHERE id = 1 AND version = ?;
-- affected rows = 0 nghĩa là có người sửa trước, đọc lại rồi thử lại

Write skew: ví dụ và cách chặn

Ý chính: write skew lọt qua vì hai bên sửa hai dòng khác nhau, nên không có xung đột nào để phát hiện. Cách chặn là biến xung đột “ẩn” thành xung đột trên cùng một dòng.

Ca 7 có hai bác sĩ trực, cả hai cùng bấm “xin nghỉ”. Mỗi transaction đếm thấy 2 người, cho nghỉ, rồi sửa dòng của chính mình. Cả MySQL RR lẫn Postgres RR đều cho qua, và ca 7 không còn ai.

-- Cách 1: khoá chính những dòng đã đọc để ra quyết định
START TRANSACTION;
SELECT doctor_id FROM doctor_shift
WHERE shift_id = 7 AND on_call = TRUE
FOR UPDATE;                         -- transaction thứ hai phải chờ ở đây
-- ứng dụng đếm: còn >= 2 người thì mới cho nghỉ
UPDATE doctor_shift SET on_call = FALSE WHERE shift_id = 7 AND doctor_id = 42;
COMMIT;

-- Cách 2: khoá một dòng "đại diện" cho cả nhóm (materialize the conflict)
START TRANSACTION;
SELECT id FROM shift WHERE id = 7 FOR UPDATE;
-- ... đọc, kiểm tra, ghi như trên
COMMIT;
  • Không viết SELECT COUNT(*) ... FOR UPDATE: MySQL chấp nhận, nhưng PostgreSQL báo lỗi vì không cho FOR UPDATE đi cùng hàm tổng hợp.
  • Cách 2 cần khi tập dòng cần khoá có thể chưa tồn tại (ví dụ “không đặt hai lịch chồng giờ”), vì không khoá được dòng chưa có.
  • Trên Postgres còn có thể chạy SERIALIZABLE và retry khi gặp lỗi serialization.

Chọn isolation level trong thực tế

Ý chính: nhiều hệ thống MySQL lớn chuyển từ RR sang READ COMMITTED để bớt gap lock và deadlock. Nhưng không level nào trong hai cái thay được update nguyên tử, khoá tường minh hay version.

So sánh chi tiết READ COMMITTED và REPEATABLE READ trên MySQL

3. Locking và MVCC

Ý chính: ghi thì khoá (lock), đọc thường thì không khoá mà đọc một phiên bản cũ (MVCC). Phần lớn sự cố đến từ khoá nhiều hơn mình nghĩ, giữ khoá quá lâu, hoặc retry sai chỗ.

3.1. Các loại lock trong InnoDB

Ý chính: InnoDB khoá bản ghi trong index, không khoá “dòng” trừu tượng; ở RR nó còn khoá cả khoảng trống giữa các bản ghi.

  • Shared (S) và Exclusive (X) ở mức dòng: SELECT ... FOR SHARE lấy S; FOR UPDATE, UPDATE, DELETE lấy X.
  • Gap lock khoá khoảng trống giữa các bản ghi index. Next-key lock = record lock + gap lock trước nó. Có ở RR để chống phantom, gần như không dùng ở READ COMMITTED, và là nguồn deadlock “khó hiểu” khi nhiều transaction insert vào cùng một khoảng.
  • Metadata lock (MDL): ALTER TABLE phải chờ mọi transaction đang dùng bảng kết thúc. Một transaction quên commit + một lệnh ALTER = mọi query sau xếp hàng chờ, sự cố production kinh điển.

Muốn thấy chính xác từng câu khoá gì (record, gap, next-key, insert intention, intention lock, AUTO-INC) ở RR và RC, bài Lock trong InnoDB đọc performance_schema.data_locks cho từng trường hợp trên MySQL 8.4.

3.2. SKIP LOCKED và NOWAIT

Ý chính: FOR UPDATE SKIP LOCKED cho nhiều worker cùng lấy việc từ một bảng mà không giành nhau và không chờ nhau. NOWAIT thì báo lỗi ngay thay vì chờ lock.

Mẫu “job queue trong database” (MySQL 8+, Postgres 9.5+):

START TRANSACTION;
SELECT id FROM job
WHERE status = 'READY' AND run_at <= NOW()
ORDER BY run_at
LIMIT 10
FOR UPDATE SKIP LOCKED;     -- worker khác đã khoá dòng nào thì bỏ qua dòng đó
UPDATE job SET status = 'RUNNING' WHERE id IN (...);
COMMIT;

Bản đầy đủ (lease locked_until cho worker chết giữa chừng, job dọn việc quá hạn, partial index chỉ trên dòng còn chờ) nằm ở mục “Database làm queue” của bài Message broker và cách chọn broker.

Job queue trong database hay message broker

3.3. Deadlock

Ý chính: deadlock là vòng chờ (T1 giữ A chờ B, T2 giữ B chờ A). InnoDB tự phát hiện và rollback một bên với lỗi 1213; việc của bạn là làm nó hiếm và retry khi nó xảy ra.

Cách phòng:

  1. Khoá theo thứ tự nhất quán, ví dụ chuyển tiền luôn khoá tài khoản id nhỏ trước.
  2. Giữ transaction ngắn, không gọi mạng bên trong.
  3. Có index cho WHERE của UPDATE/DELETE để khoá ít dòng.
  4. Retry có giới hạn: deadlock là chuyện bình thường của hệ thống đồng thời, không phải bug loại bỏ được tuyệt đối. Xem lần gần nhất bằng SHOW ENGINE INNODB STATUS.

Bài Đặt vé máy bay: giữ ghế khi nhiều người cùng đặt áp các ý này vào bài toán thật: deadlock khi khoá ghế theo thứ tự khách bấm (sửa bằng ORDER BY cố định), bẫy SKIP LOCKED báo hết ghế khi vẫn còn ghế, và conditional update cho bộ đếm ghế không cần khoá trước.

3.4. MVCC: đọc không chặn ghi

Ý chính: MVCC (Multi-Version Concurrency Control) là DB giữ nhiều phiên bản của một dòng, để người đọc đọc bản hợp với snapshot của mình thay vì chờ người ghi. Cái giá: bản cũ chỉ được dọn khi không còn snapshot nào cần.

  • InnoDB: bản mới nhất nằm trong clustered index; bản cũ dựng lại từ undo log theo chuỗi con trỏ. Mỗi consistent read có một read view (danh sách transaction đang chạy) để chọn phiên bản thấy được. RC tạo read view mới cho mỗi câu lệnh, RR tạo một lần cho cả transaction.
  • PostgreSQL: mỗi UPDATE tạo bản sao dòng mới trong heap (vùng chứa dòng của bảng), bản cũ được đánh dấu bằng xmax. VACUUM dọn bản cũ sau.

Bên trong MVCC (undo log, read view, purge, số đo history list length) và so sánh với PostgreSQL nằm ở bài Transaction từ bên trong; cách tìm và sửa transaction mở quá lâu nằm ở bài Transaction gây hại.

3.5. Check-then-insert và gap lock

Ý chính: “nếu chưa có thì tạo” kèm FOR UPDATE không chặn được trùng, mà ở RR còn gây deadlock. Chỉ unique constraint chặn chắc chắn.

START TRANSACTION;
SELECT * FROM wallet WHERE user_id = 42 FOR UPDATE;   -- chưa có dòng nào
-- ứng dụng thấy rỗng nên insert
INSERT INTO wallet (user_id, balance) VALUES (42, 0);
COMMIT;

Unique constraint còn là nền của idempotency. Bài Idempotency phần 1 giải thích vì sao lock (kể cả FOR UPDATE hay Redis lock) không phải idempotency: lock chặn chạy song song, không chặn retry tới sau khi lần đầu đã xong. Bài đó cũng đo được: ở PostgreSQL, INSERT ... ON CONFLICT DO NOTHING thứ hai chờ transaction đang giữ cùng key commit hoặc rollback rồi mới trả kết quả.

3.6. Retry đúng cách

Ý chính: deadlock, lock wait timeout và lỗi serialization là chuyện bình thường, nên ứng dụng phải retry. Nhưng phải retry cả transaction: mỗi lần thử là một transaction mới.

@Service
public class TransferService {
    private final TransactionTemplate tx;
    private final AccountRepository accounts;

    public TransferService(TransactionTemplate tx, AccountRepository accounts) {
        this.tx = tx;
        this.accounts = accounts;
    }

    // KHÔNG đặt @Transactional ở đây: mỗi lần thử phải là một transaction mới
    public void transfer(long from, long to, BigDecimal amount) {
        for (int attempt = 1; ; attempt++) {
            try {
                tx.executeWithoutResult(status -> doTransfer(from, to, amount));
                return;
            } catch (ConcurrencyFailureException e) {   // deadlock, lock timeout, serialization, optimistic
                if (attempt == 3) throw e;
                sleepQuietly(ThreadLocalRandom.current().nextLong(20, 50L * attempt));
            }
        }
    }

    private void doTransfer(long from, long to, BigDecimal amount) {
        // khoá theo thứ tự id tăng dần, xem bài tập 3
    }

    private static void sleepQuietly(long millis) {
        try { Thread.sleep(millis); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); }
    }
}

Spring dịch deadlock MySQL (1213) và lỗi serialization Postgres (SQLState 40001) thành lớp con của ConcurrencyFailureException, nên bắt lớp cha là đủ. @Retryable (Spring Retry) cũng được, miễn nằm bên ngoài proxy transaction.

Bài Code review: hai buổi review mẫu chỉ ra các lỗi này trong một PR thật: luồng đặt phòng Spring Boot gửi email và phát event ngay trong transaction.

3.7. Advisory lock: khoá theo tên

Ý chính: khi thứ cần khoá là một “việc” chứ không phải một dòng (chỉ một instance chạy job đối soát 2 giờ sáng, chỉ một request tạo báo cáo cho khách 42), database có sẵn advisory lock theo tên.

Advisory lock trong MySQL và PostgreSQL

Khi việc cần khoá không nằm trong transaction DB (gọi API ngoài, job trên nhiều pod), người ta hay nghĩ tới Redis lock. Mục “Khi nào không cần Redis lock” của bài Review code distributed lock bằng Redis so Redis lock với các cơ chế của database (câu lệnh có điều kiện, optimistic lock, FOR UPDATE, advisory lock) và chỉ ra lúc nào mới thật sự cần Redis.

Bài tập

Khoá học không có bài tập phần này; đây là các bài mình tự đặt.

Bài 1: Bán hàng flash sale không bị âm kho

Đề: 1.000 request đồng thời mua sản phẩm còn 1 cái. Code hiện tại: đọc stock, if (stock > 0) thì UPDATE stock = stock - 1. Kết quả bán được nhiều hơn 1. Sửa.

Lời giải bài 1

Bỏ check-then-act ở ứng dụng, đẩy điều kiện vào câu UPDATE nguyên tử:

UPDATE product SET stock = stock - 1 WHERE id = :id AND stock >= 1;

Chạy thử: lần mua thứ nhất affected rows = 1, lần thứ hai = 0. Trong Java, int updated = repo.decrementStock(id); updated == 0 thì trả “hết hàng”. Câu UPDATE lấy X lock trên dòng nên các request tuần tự hoá ngay trên dòng đó, không cần SELECT ... FOR UPDATE riêng. Thêm CHECK (stock >= 0) làm lưới an toàn cuối. Ở quy mô rất lớn, một dòng “nóng” thành nút thắt; khi đó mới cần Redis DECR hoặc chia kho thành nhiều dòng (bucket).

Cùng mẹo update có điều kiện còn làm handler idempotent: trong case study tự huỷ chuyến xe ở Redis: chọn cấu trúc dữ liệu, lệnh huỷ là UPDATE ride SET status = 'CANCELLED' WHERE id = ? AND status = 'WAITING', nên worker chạy trùng hay tranh với tài xế vừa nhận chuyến chỉ nhận về 0 dòng.

Bài 2: Job queue nhiều worker

Đề: 5 instance cùng xử lý bảng job, đôi khi một job bị chạy hai lần. Sửa.

Lời giải bài 2

Mỗi worker lấy job bằng SELECT ... FOR UPDATE SKIP LOCKED rồi đổi trạng thái sang RUNNING trong cùng transaction (mục 3.2). Cần index (status, run_at). Thêm locked_until/heartbeat để job của worker chết giữa chừng được nhận lại, và làm handler idempotent, vì “exactly once” không có thật khi có crash.

Bài 3: Chuyển tiền không deadlock

Đề: API chuyển tiền giữa hai tài khoản. Khi A chuyển cho B và B chuyển cho A cùng lúc, log thỉnh thoảng có lỗi deadlock 1213. Sửa sao cho không deadlock và không bao giờ âm số dư.

Lời giải bài 3

Deadlock vì request 1 khoá A rồi chờ B, request 2 khoá B rồi chờ A. Luôn khoá theo thứ tự id tăng dần, bất kể chiều chuyển:

START TRANSACTION;
SELECT id, balance FROM account WHERE id = LEAST(:from_id, :to_id)    FOR UPDATE;
SELECT id, balance FROM account WHERE id = GREATEST(:from_id, :to_id) FOR UPDATE;
-- ứng dụng kiểm tra balance của :from_id >= :amount, không đủ thì ROLLBACK
UPDATE account SET balance = balance - :amount WHERE id = :from_id;
UPDATE account SET balance = balance + :amount WHERE id = :to_id;
INSERT INTO transfer_log (from_id, to_id, amount) VALUES (:from_id, :to_id, :amount);
COMMIT;
  • Hai request ngược chiều cùng xin lock tài khoản id nhỏ trước, nên một bên chờ bên kia xong hẳn, không còn vòng chờ.
  • Thêm CHECK (balance >= 0) làm lưới an toàn.
  • Vẫn giữ vòng retry ở mục 3.6, vì deadlock còn có thể đến từ chỗ khác (gap lock, index phụ).
  • from_id = to_id thì từ chối ngay ở ứng dụng. Client nên gửi kèm idempotency key để bấm hai lần không chuyển hai lần.

Ghi nhớ

  • Giải thích được vì sao MySQL REPEATABLE READ vẫn mất cập nhật, còn PostgreSQL RR thì báo lỗi.
  • Kể được bốn cách sửa lost update và biết khi nào chọn optimistic, khi nào pessimistic.
  • Giải thích được write skew và hai cách biến nó thành xung đột trên cùng một dòng.
  • Biết vì sao FOR UPDATE trên dòng chưa tồn tại gây deadlock, và cái gì thay thế nó.
  • Viết được vòng retry đặt đúng chỗ: ngoài transaction, có giới hạn, có backoff.

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

Junior

ACID là gì?

Bốn tính chất của transaction: Atomicity, Consistency, Isolation, Durability.

Atomicity: tất cả hoặc không gì cả. Consistency: luôn giữ ràng buộc hợp lệ. Isolation: transaction đồng thời không thấy trạng thái dở dang của nhau (theo mức isolation). Durability: đã commit thì không mất khi crash, nhờ redo log/WAL.

Dirty read, non-repeatable read và phantom read khác nhau thế nào?

Dirty read đọc dữ liệu chưa commit; non-repeatable read đọc lại một dòng ra giá trị khác; phantom read chạy lại một điều kiện thấy thêm dòng mới.

Non-repeatable read do transaction khác sửa và commit; phantom do transaction khác insert. READ COMMITTED chặn cái đầu, REPEATABLE READ chặn thêm cái thứ hai, SERIALIZABLE chặn cả ba.

Mid

Optimistic và pessimistic locking khác nhau thế nào? Khi nào dùng cái nào?

Optimistic không khoá mà kiểm tra version khi ghi; pessimistic khoá dòng ngay khi đọc bằng SELECT ... FOR UPDATE.

Optimistic: xung đột thì retry; hợp khi xung đột hiếm và cần giữ qua nhiều request. Pessimistic: hợp khi xung đột thường xuyên hoặc retry đắt, nhưng giảm throughput và có thể deadlock.

Deadlock là gì và bạn phòng tránh thế nào?

Hai hay nhiều transaction chờ lock của nhau thành vòng; InnoDB phát hiện và rollback một bên (lỗi 1213).

Ví dụ T1 giữ A chờ B, T2 giữ B chờ A. Phòng: khoá theo thứ tự nhất quán, giữ transaction ngắn, có index cho WHERE của UPDATE/DELETE để khoá ít dòng, và luôn có retry giới hạn bọc ngoài transaction vì không thể loại bỏ deadlock hoàn toàn.

FOR UPDATE SKIP LOCKED dùng để làm gì?

Để nhiều worker lấy việc từ một bảng mà không giành nhau và không chờ nhau.

Mỗi worker khoá một lô dòng sẵn sàng, dòng nào worker khác đã khoá thì bỏ qua. Dùng cho job queue trong database, phát vé/mã giảm giá từ kho có sẵn. Cần index cho điều kiện lọc và thứ tự, và handler phải idempotent vì worker có thể chết giữa chừng.

Senior

MySQL REPEATABLE READ có chống được lost update không? So với PostgreSQL.

Không, nếu ứng dụng đọc rồi ghi lại giá trị tính sẵn; PostgreSQL RR thì phát hiện và ném serialization error.

InnoDB cho câu UPDATE ghi đè lên bản mới nhất mà không báo lỗi. PostgreSQL RR thấy dòng đã bị transaction khác sửa sau snapshot và báo lỗi để ứng dụng retry. Cách sửa trung lập DB: update nguyên tử (SET x = x + ?), điều kiện trong WHERE, FOR UPDATE, hoặc optimistic version.

Write skew là gì, isolation level nào chặn được?

Hai transaction đọc cùng tập dữ liệu, mỗi bên sửa một dòng khác nhau, gộp lại phá ràng buộc; chỉ SERIALIZABLE (Postgres SSI) hoặc khoá tường minh chặn được.

Ví dụ hai bác sĩ cùng xin nghỉ khi chỉ còn hai người trực. Snapshot isolation (MySQL RR, Postgres RR) không chặn được. Cách khác: FOR UPDATE trên các dòng liên quan, khoá một dòng “đại diện”, hoặc biến ràng buộc thành constraint của DB.

MVCC hoạt động thế nào trong InnoDB và vì sao transaction dài nguy hiểm?

Mỗi dòng trỏ tới undo log chứa phiên bản cũ, read view chọn bản thấy được; transaction dài giữ read view cũ nên purge không dọn được undo.

Mỗi dòng có id transaction cuối cùng sửa nó và con trỏ tới undo log. Consistent read dựng lại phiên bản từ undo nếu cần. Transaction dài làm history list length tăng, mọi đọc lội qua chuỗi phiên bản dài hơn. Nó còn giữ lock và metadata lock, có thể chặn ALTER TABLE.

Một câu UPDATE gây khoá diện rộng và deadlock, bạn điều tra thế nào?

Trước hết kiểm tra WHERE có dùng index không, vì InnoDB khoá mọi bản ghi index nó quét.

Xem SHOW ENGINE INNODB STATUS (phần LATEST DETECTED DEADLOCK) và performance_schema.data_locks để biết khoá nào đang giữ/chờ. Sửa: thêm index, khoá theo thứ tự nhất quán, rút ngắn transaction, cân nhắc READ COMMITTED để giảm gap lock nếu nghiệp vụ cho phép, và retry khi deadlock.

Vì sao vòng retry phải nằm ngoài transaction?

Vì deadlock hay lỗi serialization rollback cả transaction, nên mỗi lần thử phải là một transaction mới.

Spring còn đánh dấu transaction là rollback-only; chạy lại một câu bên trong sẽ mất thay đổi trước đó hoặc kết thúc bằng UnexpectedRollbackException. Dùng TransactionTemplate trong vòng lặp, hoặc @Retryable bọc ngoài proxy @Transactional, có giới hạn số lần, backoff ngẫu nhiên, và không có side effect bên ngoài trong transaction.

Hai request cùng “nếu chưa có thì tạo” một bản ghi. Làm sao không bị trùng?

Dùng unique constraint trên khoá nghiệp vụ và để DB từ chối bản trùng; kiểm tra ở ứng dụng luôn có race.

SELECT ... FOR UPDATE trên dòng chưa tồn tại không giúp, ở RR còn gây deadlock vì gap lock hai bên không xung đột nhưng cùng chặn insert của nhau. Dùng INSERT ... ON DUPLICATE KEY UPDATE/INSERT IGNORE (MySQL) hoặc ON CONFLICT (Postgres), hoặc insert rồi bắt lỗi duplicate để đọc lại bản ghi đã có.

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
isolation level /ˌaɪsəˈleɪʃn ˈlevl/ mức cô lập “Postgres defaults to READ COMMITTED, while MySQL defaults to REPEATABLE READ.”
lost update /lɒst ˈʌpdeɪt/ mất cập nhật “A read-modify-write in application code caused a lost update.”
write skew /raɪt skjuː/ lệch ghi “Snapshot isolation doesn’t prevent write skew; you need SERIALIZABLE or explicit locks.”
deadlock /ˈdedlɒk/ khoá chết “We avoid deadlocks by always locking accounts in ascending id order.”
pessimistic locking /ˌpesɪˈmɪstɪk ˈlɒkɪŋ/ khoá bi quan “Pessimistic locking makes sense when conflicts are frequent.”
optimistic locking /ˌɒptɪˈmɪstɪk ˈlɒkɪŋ/ khoá lạc quan “With optimistic locking, a version column detects concurrent changes.”
dirty read /ˈdɜːti riːd/ đọc dữ liệu chưa commit “READ COMMITTED already rules out dirty reads.”
gap lock /ɡæp lɒk/ khoá khoảng trống giữa các bản ghi index “The deadlock came from gap locks taken by two locking reads on a missing row.”
serialization failure /ˌsɪəriəlaɪˈzeɪʃn ˈfeɪljə/ lỗi do DB không xếp được các transaction thành thứ tự tuần tự “On a serialization failure we retry the whole transaction.”
idempotent /ˌaɪdemˈpəʊtənt/ chạy nhiều lần cùng kết quả “Job handlers must be idempotent because retries will happen.”
bloat /bləʊt/ phình to “Long-running transactions cause table bloat in Postgres.”

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