Transaction, cô lập và xử lý đồng thời
Hiểu transaction và ACID, các mức cô lập, lost update, SELECT FOR UPDATE, SKIP LOCKED, deadlock — kèm kịch bản hai phiên đã được chạy thật để thấy chính xác điều gì xảy ra.
Mọi hệ thống có nhiều hơn một người dùng đều có xử lý đồng thời — và bug đồng thời là loại bug khó tái hiện, khó gỡ, đắt nhất: bán vượt tồn kho, trừ tiền hai lần, hai worker xử lý cùng một đơn. Chúng không xuất hiện trong test một người dùng mà bùng nổ khi hệ thống đông. Hiểu transaction và khoá là ranh giới giữa "code chạy" và "code đúng dưới tải".
🎯 Mục tiêu học tập
- Giải thích ACID và dùng BEGIN/COMMIT/ROLLBACK/SAVEPOINT đúng cách
- Phân biệt READ COMMITTED, REPEATABLE READ, SERIALIZABLE và các hiện tượng (non-repeatable read, phantom, lost update, write skew)
- Chọn đúng công cụ: cập nhật nguyên tử, SELECT FOR UPDATE, khoá lạc quan (version), SKIP LOCKED, advisory lock
- Nhận diện và phòng tránh deadlock, transaction mở quá lâu và các lỗi tiêu biểu ở lớp ứng dụng
Transaction và ACID
Transaction gom nhiều câu lệnh thành một đơn vị công việc: hoặc tất cả cùng có hiệu lực (COMMIT), hoặc không cái nào (ROLLBACK).
| Chữ cái | Nghĩa | Ví dụ |
|---|---|---|
| Atomicity | Tất cả hoặc không gì cả | Chuyển tiền: trừ A và cộng B cùng thành công hoặc cùng huỷ |
| Consistency | Từ trạng thái hợp lệ sang hợp lệ (ràng buộc luôn đúng) | Kho không bao giờ âm (CHECK) |
| Isolation | Các transaction đồng thời không giẫm lên nhau | Hai khách mua món cuối cùng — chỉ một người được |
| Durability | Đã commit là không mất (kể cả sập nguồn) | WAL được ghi xuống đĩa trước khi báo thành công |
CREATE TEMP TABLE tai_khoan (id int PRIMARY KEY, ten text, so_du numeric NOT NULL CHECK (so_du >= 0));
INSERT INTO tai_khoan VALUES (1, 'An', 1000000), (2, 'Bình', 500000);
-- Chuyển 300.000 từ An sang Bình: hai UPDATE phải cùng thành công
UPDATE tai_khoan SET so_du = so_du - 300000 WHERE id = 1;
UPDATE tai_khoan SET so_du = so_du + 300000 WHERE id = 2;
SELECT * FROM tai_khoan ORDER BY id;CREATE TABLE
INSERT 0 2
UPDATE 1
UPDATE 1
id | ten | so_du
----+------+--------
1 | An | 700000
2 | Bình | 800000
(2 rows)CREATE TEMP TABLE tai_khoan (id int PRIMARY KEY, ten text, so_du numeric NOT NULL CHECK (so_du >= 0));
INSERT INTO tai_khoan VALUES (1, 'An', 1000000), (2, 'Bình', 500000);
-- (khối này đã nằm trong một transaction; trên máy bạn hãy mở đầu bằng BEGIN;)
SAVEPOINT truoc_khi_chuyen;
UPDATE tai_khoan SET so_du = so_du - 2000000 WHERE id = 1; -- vi phạm CHECK => lỗi
ROLLBACK TO truoc_khi_chuyen; -- quay về điểm đánh dấu, giao dịch ngoài vẫn dùng được
SELECT * FROM tai_khoan ORDER BY id;CREATE TABLE
INSERT 0 2
ERROR: new row for relation "tai_khoan" violates check constraint "tai_khoan_so_du_check"
DETAIL: Failing row contains (1, An, -1000000).
id | ten | so_du
----+------+---------
1 | An | 1000000
2 | Bình | 500000
(2 rows)Ngoài BEGIN, mỗi câu lệnh là một transaction riêng và commit ngay. Chuyển tiền bằng hai câu lệnh rời mà sập giữa chừng sẽ mất tiền. Nhiều driver/ORM mở transaction ngầm; hãy biết framework của bạn làm gì
(autocommit bật/tắt, ranh giới transaction nằm ở request hay service method).
PostgreSQL: sau một lỗi, transaction vào trạng thái aborted — mọi lệnh sau đều lỗi "current transaction is aborted" cho đến khi ROLLBACK (hoặc ROLLBACK TO SAVEPOINT). Ở code ứng dụng, nếu catch ngoại lệ SQL mà không rollback thì phần còn lại chạy vô nghĩa.
Dùng SAVEPOINT cho thao tác "thử, lỗi thì bỏ qua" bên trong transaction lớn.
Các mức cô lập và hiện tượng bất thường
PostgreSQL dùng MVCC: người đọc không chặn người ghi và ngược lại — mỗi transaction thấy một "ảnh chụp" (snapshot) dữ liệu. Mức cô lập quyết định khi nào chụp ảnh.
| Mức | Snapshot | Ngăn được | Ghi chú |
|---|---|---|---|
READ COMMITTED (mặc định) | Mỗi câu lệnh thấy dữ liệu đã commit tại lúc câu lệnh bắt đầu | Đọc dữ liệu chưa commit (dirty read) | Hai lần SELECT trong cùng transaction có thể ra khác nhau |
REPEATABLE READ | Cả transaction thấy một ảnh chụp | + non-repeatable read, phantom (ở PG) | Ghi vào dòng đã bị người khác đổi → lỗi could not serialize access, phải thử lại |
SERIALIZABLE | Như trên + phát hiện xung đột phụ thuộc | + write skew — kết quả như chạy tuần tự | Phải bắt lỗi 40001 và thử lại toàn bộ transaction |
Đây là kịch bản hai phiên psql chạy thật (A và B là hai kết nối). Mức mặc định, READ COMMITTED — non-repeatable read:
Phiên A Phiên B
BEGIN;
SELECT count(*) FROM orders WHERE status='pending'; -- 40
UPDATE orders SET status='paid' WHERE id = 9; -- tự commit
SELECT count(*) FROM orders WHERE status='pending'; -- 39 (cùng transaction, kết quả khác!)
COMMIT;
Với REPEATABLE READ, phiên A vẫn thấy 40 ở cả hai lần, nhưng nếu A cố ghi vào dòng mà B đã đổi:
Phiên A: BEGIN ISOLATION LEVEL REPEATABLE READ;
Phiên A: SELECT qty_on_hand FROM inventory WHERE product_id = 1; --> 16
Phiên B: UPDATE inventory SET qty_on_hand = qty_on_hand + 5 WHERE product_id = 1; (commit ngay)
Phiên A: UPDATE inventory SET qty_on_hand = qty_on_hand - 1 WHERE product_id = 1;
ERROR: could not serialize access due to concurrent update
Phiên A: ROLLBACK; -- ứng dụng phải chạy lại toàn bộ transaction- Mặc định
READ COMMITTED+ viết câu lệnh đúng (cập nhật nguyên tử, khoá tường minh) đủ cho 95% ứng dụng. - Báo cáo cần nhất quán trên nhiều câu truy vấn →
REPEATABLE READ(chỉ đọc, không lo lỗi). - Logic phức tạp "kiểm tra điều kiện rồi ghi" trên nhiều dòng (đặt lịch, ràng buộc không biểu diễn được bằng constraint) →
SERIALIZABLEkèm cơ chế retry. - Mọi mức trên mức mặc định đều đòi hỏi ứng dụng biết thử lại khi gặp lỗi serialization (SQLSTATE 40001) — nếu không có retry, đừng bật.
Lost update: bug đồng thời kinh điển và 4 cách chữa
Mẫu "đọc – tính ở ứng dụng – ghi lại" (read-modify-write) là nguồn của lost update. Hai người cùng mua món hàng còn 16 cái:
Phiên A Phiên B
BEGIN; BEGIN;
SELECT qty_on_hand ... --> 16 SELECT qty_on_hand ... --> 16
UPDATE ... SET qty_on_hand = 16 - 1; -- (ứng dụng tự tính 15)
COMMIT;
UPDATE ... SET qty_on_hand = 16 - 1; -- cũng tính ra 15
COMMIT;
Kết quả: qty_on_hand = 15 (đúng ra phải là 14 — một lần bán đã "biến mất")
Kịch bản này đã được chạy thật trên PostgreSQL và cho kết quả 15. Có bốn cách chữa, từ đơn giản đến phức tạp:
Cách 1 — Cập nhật nguyên tử trong một câu lệnh (nên dùng đầu tiên)
-- Không đọc ra ứng dụng; để database tính trên giá trị mới nhất. Điều kiện kho ở trong WHERE.
UPDATE inventory
SET qty_on_hand = qty_on_hand - 3
WHERE product_id = 1 AND qty_on_hand >= 3
RETURNING qty_on_hand; -- không có dòng trả về => hết hàng qty_on_hand
-------------
13
(1 row)
UPDATE 1-- Hết hàng: câu UPDATE không khớp dòng nào ('UPDATE 0') — ứng dụng đọc số dòng bị ảnh hưởng để biết
UPDATE inventory SET qty_on_hand = qty_on_hand - 100 WHERE product_id = 1 AND qty_on_hand >= 100;UPDATE 0
Hai phiên cùng chạy câu UPDATE ... SET qty = qty - 1: phiên thứ hai chờ phiên thứ nhất commit rồi tính lại trên giá trị mới (PostgreSQL đánh giá lại điều kiện WHERE) → kết quả 14. Đã kiểm chứng bằng hai phiên thật.
Cách 2 — Khoá hàng khi đọc: SELECT ... FOR UPDATE
Khi cần đọc, kiểm tra nhiều điều kiện rồi mới ghi, hãy khoá dòng ngay khi đọc để người khác phải chờ:
Phiên A Phiên B
BEGIN; BEGIN;
SELECT qty_on_hand FROM inventory
WHERE product_id = 1 FOR UPDATE; --> 16 (đã khoá)
UPDATE inventory SET qty_on_hand = qty_on_hand - 1
WHERE product_id = 1; <== ĐANG CHỜ (treo) ...
UPDATE ... SET qty_on_hand = qty_on_hand - 1;
COMMIT; ... thoát chờ, chạy tiếp trên giá trị 15 mới
COMMIT;
Kết quả: qty_on_hand = 14 ✔
Cách 3 — Khoá lạc quan (optimistic locking) với cột version
Không giữ khoá lúc người dùng "đang sửa form" (có thể mất vài phút). Đọc kèm version, ghi chỉ khi version chưa đổi:
CREATE TEMP TABLE bai_viet (id int PRIMARY KEY, noi_dung text, version int NOT NULL DEFAULT 1);
INSERT INTO bai_viet VALUES (1, 'bản gốc', 1);
-- Người dùng 1 và 2 cùng đọc version 1. Người 1 lưu trước:
UPDATE bai_viet SET noi_dung = 'sửa bởi 1', version = version + 1 WHERE id = 1 AND version = 1;
-- Người 2 lưu sau với version cũ => 0 dòng ảnh hưởng => ứng dụng báo "dữ liệu đã bị người khác sửa, tải lại"
UPDATE bai_viet SET noi_dung = 'sửa bởi 2', version = version + 1 WHERE id = 1 AND version = 1;
SELECT * FROM bai_viet;CREATE TABLE
INSERT 0 1
UPDATE 1
UPDATE 0
id | noi_dung | version
----+-----------+---------
1 | sửa bởi 1 | 2
(1 row)
Cách 4 — Nâng mức cô lập lên REPEATABLE READ / SERIALIZABLE + retry
Phiên ghi vào dòng đã bị người khác đổi sẽ nhận lỗi serialization (xem kịch bản REPEATABLE READ ở trên) thay vì âm thầm ghi đè — ứng dụng thử lại.
if (stock > 0) { UPDATE ... } — giữa "kiểm tra" và "ghi" có khoảng hở cho người khác chen vào (race condition). Mọi điều kiện quan trọng phải được kiểm tra trong chính câu lệnh ghi (WHERE qty >= n), bằng khoá, hoặc bằng ràng buộc của database (CHECK (qty_on_hand >= 0) — đây là lưới an toàn cuối cùng: dù code sai, kho cũng không thể âm).
Khoá hàng, hàng đợi công việc (SKIP LOCKED) và deadlock
SELECT ... FOR UPDATE SKIP LOCKED bỏ qua dòng đang bị khoá thay vì chờ — mẫu chuẩn cho hàng đợi công việc trong database: nhiều worker lấy việc song song, không ai trùng việc ai.
Worker A Worker B
BEGIN; BEGIN;
SELECT id FROM orders WHERE status = 'pending'
ORDER BY id LIMIT 1 FOR UPDATE SKIP LOCKED; --> 9
SELECT id FROM orders WHERE status = 'pending'
ORDER BY id LIMIT 1 FOR UPDATE SKIP LOCKED; --> 19 (bỏ qua 9 đang bị A khoá)
-- xử lý đơn 9, rồi UPDATE status ...; COMMIT; -- xử lý đơn 19 ...; COMMIT;-- Mẫu lấy-và-đánh-dấu trong MỘT câu lệnh (worker xin tối đa 5 việc)
WITH viec AS (
SELECT id FROM orders WHERE status = 'pending' ORDER BY id LIMIT 5 FOR UPDATE SKIP LOCKED
)
UPDATE orders o SET status = 'paid' FROM viec WHERE o.id = viec.id
RETURNING o.id, o.status; id | status
----+--------
9 | paid
19 | paid
29 | paid
39 | paid
49 | paid
(5 rows)
UPDATE 5
Các biến thể: FOR UPDATE NOWAIT (lỗi ngay nếu bị khoá, thay vì chờ), FOR SHARE (khoá đọc: chặn người khác sửa/xoá nhưng cho đọc/khoá đọc khác), pg_advisory_xact_lock(key) (khoá theo khoá do ứng dụng tự đặt, ví dụ "chỉ một job tổng hợp chạy cùng lúc").
Deadlock
Hai transaction giữ khoá mà cái kia cần, chờ nhau vô hạn. PostgreSQL phát hiện sau deadlock_timeout (1 giây) và huỷ một trong hai. Kịch bản đã chạy thật:
Phiên A Phiên B
BEGIN; BEGIN;
UPDATE inventory SET ... WHERE product_id = 1; -- giữ khoá 1
UPDATE inventory SET ... WHERE product_id = 2; -- giữ khoá 2
UPDATE inventory SET ... WHERE product_id = 2; -- chờ B
UPDATE inventory SET ... WHERE product_id = 1; -- chờ A => vòng chờ!
ERROR: deadlock detected
DETAIL: Process 147024 waits for ShareLock on transaction 912; blocked by process 75516.
Process 75516 waits for ShareLock on transaction 911; blocked by process 147024.
HINT: See server log for query details.- Luôn lấy khoá các dòng/bảng theo cùng một thứ tự ở mọi nơi (ví dụ tăng dần theo id). Cập nhật nhiều sản phẩm trong một đơn → sắp
product_idtăng dần trước khi cập nhật. - Giữ transaction ngắn: không gọi API ngoài, không chờ người dùng bên trong transaction.
- Chấp nhận deadlock vẫn có thể xảy ra: ứng dụng nên thử lại khi gặp lỗi 40P01.
- Xem
pg_locks,pg_stat_activity(wait_event_type = 'Lock') để tìm ai đang chặn ai.
-- Tìm phiên đang bị chặn và ai chặn nó (chạy trên server thật khi nghi ngờ khoá)
SELECT a.pid, a.state, pg_blocking_pids(a.pid) AS bi_chan_boi, now() - a.xact_start AS tuoi_transaction, left(a.query, 60) AS query
FROM pg_stat_activity a
WHERE cardinality(pg_blocking_pids(a.pid)) > 0; pid | state | bi_chan_boi | tuoi_transaction | query
-----+-------+-------------+------------------+-------
(0 rows)Ứng dụng BEGIN rồi quên COMMIT (lỗi code, connection pool rò rỉ) → giữ khoá, cản trở VACUUM dọn dòng chết (bảng phình, truy vấn chậm dần), và chặn migration. Đặt idle_in_transaction_session_timeout (ví dụ 30s–5 phút) làm lưới an toàn;
giám sát pg_stat_activity theo xact_start.
🏋️ Bài tập thực hành
Viết câu lệnh giảm tồn kho sản phẩm 3 đi 4 đơn vị chỉ khi còn đủ, và cho biết bằng cách nào ứng dụng biết 'hết hàng'.
Xem lời giải & giải thích
UPDATE inventory SET qty_on_hand = qty_on_hand - 4
WHERE product_id = 3 AND qty_on_hand >= 4
RETURNING product_id, qty_on_hand; product_id | qty_on_hand
------------+-------------
3 | 34
(1 row)
UPDATE 1Nếu không có dòng nào trả về (UPDATE 0) nghĩa là điều kiện qty_on_hand >= 4 không thoả → hết hàng. Không cần SELECT trước.
Viết transaction chuyển 300.000 từ tài khoản 1 sang 2 (bảng tai_khoan có CHECK so_du >= 0). Nếu chuyển 5.000.000 thì chuyện gì xảy ra với cả hai câu UPDATE?
Xem lời giải & giải thích
CREATE TEMP TABLE tai_khoan (id int PRIMARY KEY, so_du numeric NOT NULL CHECK (so_du >= 0));
INSERT INTO tai_khoan VALUES (1, 1000000), (2, 500000);
SAVEPOINT s;
UPDATE tai_khoan SET so_du = so_du - 5000000 WHERE id = 1;
ROLLBACK TO s;
SELECT * FROM tai_khoan ORDER BY id;CREATE TABLE
INSERT 0 2
ERROR: new row for relation "tai_khoan" violates check constraint "tai_khoan_so_du_check"
DETAIL: Failing row contains (1, -4000000).
id | so_du
----+---------
1 | 1000000
2 | 500000
(2 rows)CHECK làm UPDATE đầu tiên thất bại; transaction phải ROLLBACK nên UPDATE thứ hai (cộng cho tài khoản 2) không bao giờ được commit — tính nguyên tử bảo vệ tổng tiền. Ràng buộc ở database là lưới an toàn cuối cùng cho logic ứng dụng.
Với mỗi tình huống, chọn: (a) UPDATE nguyên tử, (b) SELECT FOR UPDATE, (c) khoá lạc quan (version), (d) SKIP LOCKED, (e) SERIALIZABLE + retry:
1) Trừ kho khi bán hàng. 2) Form chỉnh sửa hồ sơ khách mở trong 10 phút. 3) 8 worker lấy đơn chờ xử lý. 4) Kiểm tra 'không có hai ca trực chồng giờ' nhưng không biểu diễn được bằng constraint.
Xem lời giải & giải thích
1) (a) — một câu lệnh, điều kiện trong WHERE. 2) (c) — không giữ khoá lúc người dùng suy nghĩ. 3) (d) — mỗi worker lấy dòng khác nhau không chờ nhau. 4) (e) — logic 'đọc nhiều dòng rồi quyết định' dễ bị write skew; SERIALIZABLE (hoặc constraint EXCLUDE ở module 9 nếu biểu diễn được) kèm cơ chế thử lại.
📚 Tài nguyên học tập
-
PostgreSQL — Concurrency ControlMVCC, mức cô lập, khoá tường minhDocs
-
PostgreSQL — Explicit LockingCác loại khoá bảng/hàng và bảng tương thíchDocs
-
Jepsen — Consistency ModelsBản đồ các mô hình nhất quán (đọc thêm)Bài viết
✅ Tự đánh giá hoàn thành
- Giải thích được ACID và cách một lỗi giữa chừng được rollback
- Nhận biết read-modify-write và chữa bằng UPDATE nguyên tử/FOR UPDATE/version
- Biết khi nào dùng REPEATABLE READ/SERIALIZABLE và bắt buộc có retry lỗi 40001/40P01
- Dùng SKIP LOCKED cho hàng đợi và khoá theo thứ tự nhất quán để tránh deadlock