Cụm bài Thread và concurrency trong Java: 1. Tạo thread và vòng đời · 2. Race condition, volatile, deadlock · 3. ExecutorService và virtual thread
Khi các thread dùng chung dữ liệu, ba lỗi xuất hiện: số đếm bị lệch, thread này không thấy thay đổi của thread kia, và hai thread chờ nhau mãi mãi. Đọc xong, bạn sửa được cả ba và tìm ra deadlock bằng thread dump. Nên đọc phần 1 trước, nhất là trạng thái BLOCKED và join(); mọi demo đã chạy trên JDK 21.
1. Race condition: khi nhiều thread cùng sửa một biến
Ý chính: count++ không phải một bước mà là đọc, cộng, ghi. Hai thread xen vào giữa nhau thì mất lượt cộng; sửa bằng lock, CAS hoặc bộ đếm chia ô.
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;
public class RaceCondition {
static final int THREADS = 4;
static final int PER_THREAD = 1_000_000;
static int unsafeCount = 0;
static int syncCount = 0;
static synchronized void syncIncrement() { syncCount++; }
static final AtomicInteger atomicCount = new AtomicInteger();
static final LongAdder adder = new LongAdder();
static void runInParallel(Runnable increment) throws InterruptedException {
List<Thread> threads = new ArrayList<>();
for (int i = 0; i < THREADS; i++) {
Thread t = new Thread(() -> {
for (int j = 0; j < PER_THREAD; j++) increment.run();
});
threads.add(t);
t.start();
}
for (Thread t : threads) t.join();
}
public static void main(String[] args) throws InterruptedException {
runInParallel(() -> unsafeCount++);
runInParallel(RaceCondition::syncIncrement);
runInParallel(atomicCount::incrementAndGet);
runInParallel(adder::increment);
System.out.println("expected = " + THREADS * PER_THREAD);
System.out.println("unsafe = " + unsafeCount);
System.out.println("synchronized = " + syncCount);
System.out.println("atomic = " + atomicCount.get());
System.out.println("LongAdder = " + adder.sum());
}
}
// expected = 4000000
// unsafe = 1252965 (mỗi lần chạy ra một số khác)
// synchronized = 4000000
// atomic = 4000000
// LongAdder = 4000000
Mất gần 70% lượt cộng vì hai thread cùng đọc 10, cùng cộng thành 11, cùng ghi 11. Race condition là khi kết quả phụ thuộc vào thứ tự xen kẽ của các thread. (Bài Java cơ bản có nhắc i++ không atomic; đây là bản demo đầy đủ.)
Hai dạng race hay gặp:
- Read-modify-write (đọc-sửa-ghi):
count++,balance -= amount,map.put(k, map.get(k) + 1). - Check-then-act (kiểm tra rồi làm):
if (stock > 0) stock--,if (!map.containsKey(k)) map.put(k, v), “kiểm tra username tồn tại rồi insert”. Giữa lúc kiểm tra và lúc làm, thread khác đã đổi trạng thái.
Race không chỉ có trong một JVM. Cache và database không có giao dịch chung, nên writer xoá cache còn reader chậm nạp lại giá trị cũ cũng là check-then-act. Bài Cache-aside và bài toán lệch dữ liệu cache–DB dựng lại từng thứ tự xen kẽ đó và cách đóng khe hở (xoá sau commit, TTL, version, lease).
Ba cách sửa trong demo:
synchronized: mỗi object có một monitor (khoá ngầm gắn với object). Chỉ một thread được ở trong khốisynchronizedcủa cùng monitor; thread khác vào trạng tháiBLOCKED.static synchronizedkhoá trênRaceCondition.class, method thường khoá trênthis. Khoá reentrant: thread đang giữ vào lại được.AtomicInteger: dùng lệnh CPU compare-and-swap (CAS): “nếu giá trị vẫn là 10 thì ghi 11, không thì báo thất bại để thử lại”. Không chặn thread nào.LongAdder: chia bộ đếm thành nhiều ô, mỗi thread cộng vào ô của mình, đọc thì cộng tổng. Nhanh nhất khi nhiều thread cùng ghi (metrics, rate counter), nhưngsum()không phải snapshot nguyên tử.
LongAdder, @Contended và false sharing
Các ô của LongAdder được đánh dấu @Contended để không nằm chung một cache line (khối 64 byte CPU nạp một lần). Nếu hai ô chung một cache line, mỗi lần một core ghi là core kia phải nạp lại cả khối: đó là false sharing, hai biến không liên quan làm nhau chậm gấp mấy lần. Số đo cụ thể ở Bộ nhớ ảo, page cache và JVM. LMAX Disruptor cũng pad các sequence ra cache line riêng vì lý do này, xem Hệ thống liveness: timing wheel và LMAX Disruptor.
2. Visibility, volatile và happens-before
Ý chính: không có đồng bộ, thread này ghi mà thread kia có thể không bao giờ thấy. volatile (hoặc lock) tạo quan hệ happens-before để bảo đảm thấy.
public class Visibility {
static boolean running = true; // thử thêm volatile
public static void main(String[] args) throws InterruptedException {
Thread worker = new Thread(() -> {
long spins = 0;
while (running) {
spins++; // không có sync, không I/O
}
System.out.println("stopped after " + spins + " spins");
});
worker.start();
Thread.sleep(1000); // để JIT kịp biên dịch vòng lặp
running = false;
System.out.println("main set running = false");
worker.join(3000);
System.out.println("worker alive after 3s? " + worker.isAlive());
System.exit(0);
}
}
// Không volatile: main set running = false
// worker alive after 3s? true <- treo vĩnh viễn
// Có volatile: main set running = false
// stopped after 3673716389 spins
// worker alive after 3s? false
Không có volatile, JIT (trình biên dịch lúc chạy) được phép coi running không đổi trong vòng lặp và kéo phép đọc ra ngoài, biến vòng lặp thành while (true). CPU cũng có cache và store buffer riêng từng core. Java Memory Model (JMM) chỉ bảo đảm một thread thấy giá trị thread khác ghi nếu giữa hai hành động có quan hệ happens-before (“A xảy ra trước B” theo nghĩa mọi thứ A ghi đều thấy được ở B).
Những quan hệ happens-before hay dùng:
| Quy tắc | Ý nghĩa |
|---|---|
| Thứ tự trong một thread | Lệnh trước happens-before lệnh sau, trong cùng thread |
| Monitor | unlock một monitor happens-before mọi lần lock sau đó trên cùng monitor |
volatile |
Ghi một biến volatile happens-before mọi lần đọc sau đó của biến ấy |
Thread.start() |
Mọi thứ trước t.start() thấy được trong thread t |
Thread.join() |
Mọi thứ thread t làm thấy được sau khi t.join() trả về |
Executor, Future |
Nộp task happens-before lúc task chạy; task kết thúc happens-before future.get() trả về |
| Bắc cầu | A hb B và B hb C thì A hb C |
Nhờ bắc cầu, volatile còn “kéo theo” biến thường: thread A ghi config = ... rồi ghi volatile ready = true; thread B thấy ready == true thì chắc chắn thấy config mới. Các class trong java.util.concurrent công bố dữ liệu an toàn theo cách này.
3. Deadlock
Ý chính: deadlock là khi các thread giữ lock và chờ lock của nhau theo vòng tròn, không ai nhả. Phá một trong bốn điều kiện Coffman là tránh được, thường bằng cách khoá theo thứ tự cố định.
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
public class Deadlock {
static final Object ORDERS = new Object();
static final Object INVENTORY = new Object();
static void pause() {
try { Thread.sleep(50); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
}
public static void main(String[] args) throws InterruptedException {
Thread checkout = new Thread(() -> {
synchronized (ORDERS) {
pause();
synchronized (INVENTORY) { System.out.println("checkout done"); }
}
}, "checkout");
Thread restock = new Thread(() -> {
synchronized (INVENTORY) {
pause();
synchronized (ORDERS) { System.out.println("restock done"); }
}
}, "restock");
checkout.setDaemon(true); // để demo thoát được dù 2 thread kẹt mãi
restock.setDaemon(true);
checkout.start();
restock.start();
Thread.sleep(500);
ThreadMXBean mx = ManagementFactory.getThreadMXBean();
long[] ids = mx.findDeadlockedThreads();
if (ids != null) {
for (ThreadInfo info : mx.getThreadInfo(ids)) {
System.out.println(info.getThreadName() + " waits for " + info.getLockName()
+ " held by " + info.getLockOwnerName());
}
}
}
}
// checkout waits for java.lang.Object@78b66d36 held by restock
// restock waits for java.lang.Object@6f96c77 held by checkout
flowchart LR
C[Thread checkout] -- giữ --> O((ORDERS))
R[Thread restock] -- giữ --> I((INVENTORY))
C -. chờ .-> I
R -. chờ .-> O
Bốn điều kiện Coffman, thiếu một là không deadlock:
- Loại trừ lẫn nhau: lock chỉ một người giữ.
- Giữ và chờ: giữ lock này trong khi chờ lock khác.
- Không cưỡng đoạt: không ai giật lock khỏi tay thread khác.
- Chờ vòng tròn: A chờ B, B chờ A.
Phát hiện
Ý chính: thread dump (jstack, jcmd Thread.print) tự in “Found one Java-level deadlock” kèm thread, lock và dòng code.
jstack <pid>hoặcjcmd <pid> Thread.print: chỉ rõ thread nào giữ và chờ lock nào.- Trong code:
ThreadMXBean.findDeadlockedThreads()(như demo), gắn được vào health check hoặc job giám sát. - Dấu hiệu ngoài đời: CPU gần 0 nhưng request treo, số thread
BLOCKEDtăng dần. Lấy 2–3 thread dump cách nhau vài giây để phân biệt deadlock (đứng yên) với tranh chấp lock nặng (có tiến triển).
Deadlock ở database (hai transaction khoá row theo thứ tự ngược nhau) thì DB tự phát hiện và huỷ một transaction; cách phòng y hệt: cập nhật row theo thứ tự cố định.
Thread dump của demo deadlock
Found one Java-level deadlock:
=============================
"checkout":
waiting to lock monitor 0x00000076a36b50a0 (object 0x0000007010375760, a java.lang.Object),
which is held by "restock"
"restock":
waiting to lock monitor 0x00000076a36b5180 (object 0x0000007010375750, a java.lang.Object),
which is held by "checkout"
...
"checkout":
at Deadlock.lambda$main$0(Deadlock.java:17)
- waiting to lock <0x0000007010375760> (a java.lang.Object)
- locked <0x0000007010375750> (a java.lang.Object)
Phòng tránh
Ý chính: lấy lock theo một thứ tự toàn cục (phá “chờ vòng tròn”), hoặc tryLock có timeout rồi nhả hết và thử lại (phá “giữ và chờ”).
// Cách 1: luôn khoá theo một thứ tự toàn cục (ở đây là id tăng dần)
static void transferOrdered(Account from, Account to, long amount) {
Account first = from.id < to.id ? from : to;
Account second = first == from ? to : from;
synchronized (first) {
synchronized (second) {
if (from.balance < amount) return;
from.balance -= amount;
to.balance += amount;
}
}
}
// Cách 2: tryLock có timeout, không lấy đủ thì nhả hết và thử lại
static boolean transferTryLock(Account from, Account to, long amount) throws InterruptedException {
long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(1);
while (System.nanoTime() < deadline) {
if (from.lock.tryLock(10, TimeUnit.MILLISECONDS)) {
try {
if (to.lock.tryLock(10, TimeUnit.MILLISECONDS)) {
try {
if (from.balance < amount) return false;
from.balance -= amount;
to.balance += amount;
return true;
} finally {
to.lock.unlock();
}
}
} finally {
from.lock.unlock();
}
}
Thread.sleep(ThreadLocalRandom.current().nextInt(1, 5)); // backoff ngẫu nhiên tránh livelock
}
return false;
}
Cả hai cách đã chạy 100.000 lần chuyển ngẫu nhiên giữa 5 tài khoản trên 8 thread: không treo, tổng tiền giữ nguyên 5.000 (đầy đủ ở Bài tập 2).
Bốn điều kiện Coffman áp dụng y hệt cho lock trong database: bài Optimistic hay pessimistic locking chỉ cách phá từng điều kiện với InnoDB (khoá theo thứ tự id, lấy mọi lock trong một câu, bộ phát hiện deadlock). synchronized chỉ khoá trong một JVM, không bảo vệ dữ liệu dùng chung trong database khi chạy nhiều instance.
Bài tập
Bài 1: Bán hàng giới hạn số lượng
Đề: flash sale có 100 sản phẩm, 10.000 request mua cùng lúc trên 16 thread. Viết buy() trả true nếu mua được. Không được bán quá 100.
Lời giải Bài 1: vòng CAS và synchronized
Lỗi hay gặp: dùng AtomicInteger nhưng tách get() và decrementAndGet(). Từng bước atomic, cả cụm check-then-act thì không:
boolean buy() { // SAI
if (left.get() > 0) {
sleepQuietly(); // giả lập chút xử lý giữa check và act
left.decrementAndGet();
return true;
}
return false;
}
Hai lời giải đúng:
// Lock-free: vòng CAS
boolean buy() {
while (true) {
int current = left.get();
if (current == 0) return false;
if (left.compareAndSet(current, current - 1)) return true;
}
}
// Khoá: đơn giản, dễ mở rộng khi cần đổi nhiều field cùng lúc
synchronized boolean buy() {
if (left == 0) return false;
left--;
return true;
}
Kết quả chạy thử (dùng CountDownLatch làm “phát súng” để mọi thread bắt đầu cùng lúc):
naive sold=114 left=-14
cas sold=100 left=0
locked sold=100
Ghi chú senior: khi app chạy nhiều instance, tồn kho phải trừ ở database (UPDATE product SET stock = stock - 1 WHERE id = ? AND stock > 0 rồi kiểm tra số dòng bị ảnh hưởng) hoặc Redis DECR; lock trong JVM chỉ bảo vệ trong một process.
Bài 2: Chuyển tiền không deadlock
Đề: 5 tài khoản, mỗi tài khoản 1.000. Chạy 100.000 lệnh chuyển ngẫu nhiên trên 8 thread. Yêu cầu: không deadlock, tổng tiền luôn là 5.000. Viết hai phiên bản: lock ordering và tryLock.
Lời giải Bài 2: chương trình chạy hai phiên bản
import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantLock;
public class Transfer {
static final class Account {
final long id;
long balance;
final ReentrantLock lock = new ReentrantLock();
Account(long id, long balance) { this.id = id; this.balance = balance; }
}
// transferOrdered và transferTryLock: như ở mục 3
public static void main(String[] args) throws Exception {
run(false);
run(true);
}
static void run(boolean useTryLock) throws Exception {
Account[] accounts = new Account[5];
for (int i = 0; i < accounts.length; i++) accounts[i] = new Account(i, 1_000);
try (ExecutorService pool = Executors.newFixedThreadPool(8)) {
for (int i = 0; i < 100_000; i++) {
pool.submit(() -> {
var rnd = ThreadLocalRandom.current();
Account a = accounts[rnd.nextInt(accounts.length)];
Account b = accounts[rnd.nextInt(accounts.length)];
if (a == b) return null;
if (useTryLock) transferTryLock(a, b, rnd.nextInt(1, 50));
else transferOrdered(a, b, rnd.nextInt(1, 50));
return null;
});
}
}
long total = 0;
for (Account a : accounts) total += a.balance;
System.out.println((useTryLock ? "tryLock" : "ordered") + " total = " + total + " (expected 5000)");
}
}
// ordered total = 5000 (expected 5000)
// tryLock total = 5000 (expected 5000)
Ba điểm cần để ý:
- Lambda dùng
Callable(córeturn null) để được phép némInterruptedExceptioncủatryLock. - Đọc
balancesau khi pool đóng là an toàn nhờ happens-before củaclose()/awaitTermination. - Không trộn hai phiên bản trên cùng tài khoản trong một lần chạy (xem pitfall về
synchronizedvàReentrantLockở mục 1).
Muốn tự thấy deadlock, đổi transferOrdered thành khoá from rồi to (không sắp thứ tự): chương trình treo và jstack báo “Found one Java-level deadlock”.
Ghi nhớ
- Giải thích được vì sao
count++mất lượt cộng và hai dạng race: read-modify-write, check-then-act. - Biết khi nào chọn
synchronized,AtomicInteger,LongAdder, và khi nào phải đẩy xuống database. - Giải thích được vì sao vòng
while (running)treo khi thiếuvolatile, và kể được 4–5 quan hệ happens-before. - Kể được bốn điều kiện Coffman và hai cách phá: lock ordering,
tryLock+ backoff. - Biết đọc thread dump để phân biệt deadlock với tranh chấp lock nặng.
Câu hỏi phỏng vấn
Junior
synchronized hoạt động thế nào?
Mỗi object có một monitor; chỉ một thread được ở trong khối synchronized của cùng monitor tại một thời điểm.
Thread khác muốn vào sẽ ở trạng thái BLOCKED. Method thường khoá trên this, static synchronized khoá trên object Class. Lock là reentrant và được nhả cả khi ra khỏi khối bằng exception. Ngoài loại trừ lẫn nhau, unlock happens-before lần lock sau trên cùng monitor, nên dữ liệu ghi trong khối được thread sau nhìn thấy.
Mid
Race condition là gì? count++ trên biến dùng chung sửa thế nào?
Race condition là khi kết quả phụ thuộc thứ tự xen kẽ của các thread; count++ sửa bằng AtomicInteger, LongAdder hoặc lock, không phải volatile.
count++ là đọc-cộng-ghi, hai thread cùng đọc một giá trị sẽ mất một lượt cộng. AtomicInteger.incrementAndGet() dùng CAS; LongAdder hợp khi nhiều thread cùng ghi (metrics); synchronized/lock khi cần bảo vệ nhiều biến hay cả chuỗi check-then-act.
volatile bảo đảm gì và không bảo đảm gì?
Bảo đảm visibility và ordering, không bảo đảm atomicity.
Ghi xong thì thread khác đọc thấy; không bị sắp xếp lại qua phép truy cập volatile; ghi volatile happens-before đọc sau đó. Thao tác nhiều bước như count++ vẫn không nguyên tử. Dùng cho cờ dừng, công bố reference tới object bất biến, double-checked locking.
Vì sao if (left.get() > 0) left.decrementAndGet() vẫn bán quá số lượng dù dùng AtomicInteger?
Vì từng thao tác atomic nhưng cả cụm check-then-act thì không.
Nhiều thread cùng thấy left == 1, cùng qua if, rồi cùng trừ, tồn kho thành số âm. Sửa bằng vòng CAS (compareAndSet(current, current - 1) chỉ thành công nếu không ai đổi giá trị giữa chừng), updateAndGet với điều kiện, hoặc đặt cả kiểm tra lẫn trừ trong một khối synchronized.
Senior
Deadlock là gì, phát hiện và phòng tránh thế nào?
Các thread giữ lock và chờ lock của nhau theo vòng tròn; phát hiện bằng thread dump, phòng bằng khoá theo thứ tự toàn cục hoặc tryLock có timeout.
- Cần đủ bốn điều kiện Coffman: loại trừ lẫn nhau, giữ và chờ, không cưỡng đoạt, chờ vòng tròn.
- Phát hiện:
jstack/jcmd Thread.print(tự in “Found one Java-level deadlock”),ThreadMXBean.findDeadlockedThreads(), dấu hiệu CPU thấp mà request treo. - Phòng tránh: khoá theo thứ tự toàn cục,
tryLockcó timeout + backoff, giữ lock ngắn, không gọi I/O/callback lạ khi đang giữ lock, hạn chế cần nhiều lock cùng lúc.
Happens-before là gì? Kể vài quan hệ happens-before quan trọng.
Quy tắc của Java Memory Model: nếu A happens-before B thì mọi thứ A ghi đều thấy được ở B và không bị sắp xếp lại qua nhau.
Không có quan hệ này thì thread khác có thể thấy giá trị cũ, thậm chí object khởi tạo dở. Các quan hệ chính: thứ tự lệnh trong một thread; unlock monitor → lock sau trên cùng monitor; ghi volatile → đọc sau đó; Thread.start() → code trong thread; code trong thread → join() trả về; nộp task vào executor → task chạy; task xong → Future.get() trả về; và tính bắc cầu.
App chạy 3 instance, synchronized có chặn được việc bán quá tồn kho không?
Không. Lock của JVM chỉ có hiệu lực trong một process; ba pod là ba monitor khác nhau.
Bất biến dùng chung giữa các instance phải giữ ở nơi dùng chung: UPDATE ... SET stock = stock - 1 WHERE id = ? AND stock > 0 rồi kiểm tra số dòng bị ảnh hưởng, row lock (SELECT ... FOR UPDATE), optimistic locking bằng cột version, hoặc DECR nguyên tử trên Redis. Lock trong JVM vẫn giúp giảm tranh chấp trong một instance, nhưng không phải chốt chặn cuối.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu trong phỏng vấn |
|---|---|---|---|
| race condition | /reɪs kənˈdɪʃən/ | tranh chấp dữ liệu | “The lost updates were caused by a race condition on a shared counter.” |
| atomic | /əˈtɒmɪk/ | nguyên tử, không chia cắt | “count++ isn’t atomic; it’s a read, an add and a write.” |
| visibility | /ˌvɪzəˈbɪləti/ | khả năng nhìn thấy thay đổi | “Without volatile, there’s no visibility guarantee between threads.” |
| happens-before | /ˈhæpənz bɪˈfɔːr/ | quan hệ xảy ra trước | “Unlocking a monitor happens-before every subsequent lock on it.” |
| deadlock | /ˈdɛdlɒk/ | khoá chết | “Two threads acquired the same locks in opposite order and deadlocked.” |
| livelock | /ˈlaɪvlɒk/ | các thread liên tục nhường nhau mà không tiến triển | “We added random backoff to the retry loop to avoid livelock.” |
| contention | /kənˈtɛnʃən/ | tranh chấp tài nguyên | “Lock contention went up as soon as we added more threads.” |
| thread dump | /θrɛd dʌmp/ | ảnh chụp trạng thái mọi thread | “I’d take two or three thread dumps a few seconds apart.” |
Ghi chép dựa trên tài liệu Java Core của Hỏi Dân IT và kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.