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
Tomcat, HikariCP, @Scheduled, Kafka consumer đều chạy trên thread; khi số đếm lệch, app treo hay người A thấy dữ liệu của người B, người hiểu thread mới tìm ra nguyên nhân. Đọc xong, bạn tạo được thread bằng Thread/Runnable/Callable, đọc được sáu trạng thái và dừng thread đúng cách bằng interrupt. Cần biết Java cơ bản và exception; phần 2 nói về race condition, volatile, deadlock, phần 3 về thread pool, virtual thread, ThreadLocal (demo chạy trên JDK 21).
1. Process, thread, concurrency và parallelism
Ý chính: process là chương trình đang chạy với bộ nhớ riêng; thread là luồng thực thi bên trong process, chung heap, và là đơn vị hệ điều hành lập lịch lên CPU.
Mỗi thread có stack riêng (biến local, frame của method) và program counter riêng. Cách OS quản lý process, thread và context switch (chuyển CPU từ thread này sang thread khác): xem Hệ điều hành cho backend: kernel, system call, process và thread.
| Process | Thread | |
|---|---|---|
| Bộ nhớ | Riêng, tách biệt | Chung heap, stack riêng |
| Chi phí tạo | Lớn (fork, bảng trang mới) | Nhỏ hơn nhiều, nhưng vẫn ~1 MB stack + một OS thread |
| Giao tiếp | IPC: socket, pipe, file | Đọc/ghi chung object trên heap |
| Một cái chết | Process khác không sao | Exception chưa bắt chỉ giết thread đó, nhưng dữ liệu chung bị hỏng thì cả process chịu |
Ví dụ “vừa nghe nhạc, vừa lướt web, vừa tải file” thật ra là ba process. Ví dụ đúng cho thread: trong một JVM, mỗi request HTTP do một thread của Tomcat xử lý.
- Concurrency (đồng thời): nhiều việc đang dở dang cùng lúc, có thể xen kẽ trên một core. Là chuyện cấu trúc.
- Parallelism (song song): nhiều việc thực sự chạy cùng thời điểm trên nhiều core. Là chuyện thực thi.
Server 2 core phục vụ 200 request cùng lúc: concurrency cao, parallelism tối đa là 2.
Khi nào thread giúp được
- I/O bound (gọi DB, HTTP, đọc file): thread chủ yếu ngồi chờ, nhiều thread giữ CPU không rảnh. Trường hợp phổ biến nhất ở backend.
- CPU bound (nén ảnh, mã hoá): thread luôn bận; thêm thread quá số core không nhanh hơn, chỉ tốn context switch.
- Giữ phản hồi: tách việc chậm (gửi email, xuất báo cáo) khỏi thread phải luôn rảnh, như thread xử lý request hay event loop của Netty.
Cái giá: race condition (dữ liệu chung bị tranh chấp), deadlock (chờ nhau mãi), lỗi khó tái hiện vì phụ thuộc thời điểm; phần 2 xoay quanh ba thứ đó.
Thêm ví dụ thread và các thread có sẵn trong JVM
- Ví dụ thread trong trình duyệt: trong một trình duyệt, một thread vẽ giao diện, một thread tải ảnh, một thread chạy JavaScript.
- Giữ phản hồi ngoài backend: thread giao diện của app desktop/Android phải luôn rảnh, nên việc chậm chạy ở thread khác.
- Mỗi chương trình Java khởi động với ít nhất thread
mainchạy methodmain, kèm vài thread nền của JVM (GC, JIT compiler, Finalizer, Signal Dispatcher).
2. Tạo thread: Thread, Runnable, Callable
Ý chính: tách “việc cần làm” (Runnable, hoặc Callable nếu cần kết quả) khỏi “người làm” (Thread hay executor), và chỉ start() mới thật sự tạo thread mới.
extends Thread và implements Runnable
// Cách 1: kế thừa Thread
class ReportThread extends Thread {
@Override
public void run() {
System.out.println("building report on " + getName());
}
}
// Cách 2: tách "việc cần làm" (Runnable) khỏi "người làm" (Thread)
Runnable sendEmail = () -> System.out.println("sending on " + Thread.currentThread().getName());
new ReportThread().start();
new Thread(sendEmail, "mailer").start();
Runnable là functional interface chỉ có void run(), nên viết bằng lambda được.
Hai thread chạy xen kẽ
Các bước: class implements Runnable, override run(), truyền object vào constructor của Thread, gọi start(). Demo bên dưới cho thấy:
mainin dòng của nó trước cả hai thread, vìstart()trả về ngay, không chờrun()xong.- Thứ tự giữa hai thread do bộ lập lịch của OS quyết định (
resize 3in trướcdownload 3dùdownloadstart trước). Đừng dựa vào nó; muốn chờ thì dùngjoin()(mục 4).
Demo hai thread đếm ngược xen kẽ và output
Hai việc đếm ngược trên hai thread, mỗi vòng nghỉ bằng Thread.sleep để thấy chúng xen kẽ:
public class Interleave {
static class Countdown implements Runnable {
private final String label;
private final long pauseMs;
Countdown(String label, long pauseMs) {
this.label = label;
this.pauseMs = pauseMs;
}
@Override
public void run() {
for (int i = 3; i >= 1; i--) {
System.out.println(label + " " + i + " on " + Thread.currentThread().getName());
try {
Thread.sleep(pauseMs);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
return;
}
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread download = new Thread(new Countdown("download", 100), "t-download");
Thread resize = new Thread(new Countdown("resize", 150), "t-resize");
download.start();
resize.start();
System.out.println("main keeps going on " + Thread.currentThread().getName());
download.join();
resize.join();
System.out.println("both done");
}
}
Một lần chạy:
main keeps going on main
resize 3 on t-resize
download 3 on t-download
download 2 on t-download
resize 2 on t-resize
download 1 on t-download
resize 1 on t-resize
both done
Callable và Future: khi cần kết quả
Runnable.run() không trả giá trị, không ném checked exception. Callable<V>.call() trả V và được throws Exception. Callable không truyền thẳng vào new Thread(...) được; đưa cho ExecutorService (phần 3) để nhận Future<V>:
import java.util.concurrent.*;
public class CallableDemo {
public static void main(String[] args) throws InterruptedException {
try (ExecutorService pool = Executors.newFixedThreadPool(2)) {
Callable<Integer> priceLookup = () -> {
Thread.sleep(200); // giả lập gọi API
return 42_000;
};
Future<Integer> price = pool.submit(priceLookup);
Future<Integer> broken = pool.submit(() -> {
throw new IllegalStateException("upstream down");
});
try {
System.out.println("price = " + price.get(1, TimeUnit.SECONDS));
broken.get();
} catch (ExecutionException e) {
System.out.println("task failed: " + e.getCause());
} catch (TimeoutException e) {
price.cancel(true);
System.out.println("too slow, cancelled");
}
}
}
}
// price = 42000
// task failed: java.lang.IllegalStateException: upstream down
get()chặn tới khi có kết quả; ở production luôn dùng bản có timeout.- Lỗi trong task được gói vào
ExecutionException, lỗi gốc ởgetCause(). cancel(true)interrupt thread đang chạy task (chỉ dừng thật nếu task tôn trọng interrupt, mục 4).- Ghép nhiều bước bất đồng bộ thì dùng
CompletableFuture;Futurethuần chỉ cóget()chặn.
start() và run()
public class StartVsRun {
public static void main(String[] args) throws InterruptedException {
Runnable task = () -> System.out.println("running in: " + Thread.currentThread().getName());
Thread t = new Thread(task, "worker-1");
t.run(); // chỉ là một lời gọi method bình thường
t.start(); // JVM tạo thread mới, thread đó gọi run()
t.join();
try {
t.start(); // lần thứ hai
} catch (IllegalThreadStateException e) {
System.out.println("start twice -> " + e.getClass().getSimpleName());
}
}
}
// running in: main
// running in: worker-1
// start twice -> IllegalThreadStateException
3. Vòng đời: 6 trạng thái của thread
Ý chính: Thread.getState() trả một trong 6 giá trị; điểm hay bị hỏi là không có RUNNING, I/O vẫn là RUNNABLE, và BLOCKED chỉ dành cho synchronized.
| Trạng thái | Nghĩa | Vào bằng cách nào |
|---|---|---|
NEW |
Đã tạo object, chưa start() |
new Thread(...) |
RUNNABLE |
Đang chạy hoặc sẵn sàng chạy, chờ OS cấp CPU | start() |
BLOCKED |
Chờ vào một khối synchronized mà thread khác đang giữ monitor |
synchronized bị tranh chấp |
WAITING |
Chờ không thời hạn đến khi thread khác đánh thức | wait(), join(), LockSupport.park() (cũng là cách ReentrantLock.lock() chờ) |
TIMED_WAITING |
Như WAITING nhưng có hạn | sleep(ms), wait(ms), join(ms), parkNanos |
TERMINATED |
run() đã kết thúc (bình thường hoặc do exception) |
Hết run() |
stateDiagram-v2
[*] --> NEW
NEW --> RUNNABLE: start
RUNNABLE --> BLOCKED: vào synchronized đang bị giữ
BLOCKED --> RUNNABLE: lấy được monitor
RUNNABLE --> WAITING: wait / join / park
WAITING --> RUNNABLE: notify / thread kia kết thúc / unpark
RUNNABLE --> TIMED_WAITING: sleep / wait có timeout / join có timeout
TIMED_WAITING --> RUNNABLE: hết giờ / được đánh thức
RUNNABLE --> TERMINATED: run kết thúc
TERMINATED --> [*]
- Java không có trạng thái “RUNNING” riêng: đang chạy trên CPU hay xếp hàng chờ CPU đều là
RUNNABLE. - Thread chặn trên I/O (đọc socket, file) vẫn báo
RUNNABLE, vì với JVM nó đang ở native code. Xem thread dump đừng nghĩ “RUNNABLE = đang đốt CPU”. BLOCKEDchỉ dành chosynchronized. Thread chờReentrantLockhiệnWAITING(lock dùngLockSupport.park).
Demo tạo đủ cả 6 trạng thái và bẫy đọc trạng thái
public class ThreadStates {
private static final Object LOCK = new Object();
public static void main(String[] args) throws Exception {
Thread sleeper = new Thread(() -> {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
System.out.println("1. " + sleeper.getState()); // NEW
sleeper.start();
Thread.sleep(100);
System.out.println("2. " + sleeper.getState()); // TIMED_WAITING
Thread blocked = new Thread(() -> {
synchronized (LOCK) { /* cần LOCK mà main đang giữ */ }
});
Thread waiter = new Thread(() -> {
try {
sleeper.join(); // chờ không giới hạn
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
synchronized (LOCK) {
blocked.start();
waiter.start();
Thread.sleep(100);
System.out.println("3. " + blocked.getState()); // BLOCKED
System.out.println("4. " + waiter.getState()); // WAITING
}
Thread spinner = new Thread(() -> {
long end = System.nanoTime() + 300_000_000L;
while (System.nanoTime() < end) { /* bận tính toán */ }
});
spinner.start();
Thread.sleep(50);
System.out.println("5. " + spinner.getState()); // RUNNABLE
sleeper.join();
waiter.join();
blocked.join();
spinner.join();
System.out.println("6. " + sleeper.getState()); // TERMINATED
}
}
4. Điều khiển thread: sleep, join, interrupt
Ý chính: sleep tạm dừng thread hiện tại, join chờ thread khác xong; muốn dừng một thread thì chỉ có interrupt(), và thread kia phải tự hợp tác.
Thread.sleep(ms): không nhả lock đang giữ.t.join()/t.join(ms): ngoài việc chờ, còn bảo đảm mọi thứtđã ghi đều nhìn thấy được sau khijointrả về (happens-before, xem phần 2).obj.wait()/obj.notifyAll(): chờ/đánh thức cấp thấp, phải giữ monitor củaobj;wait()nhả monitor khi chờ. Code mới dùngBlockingQueue,CountDownLatch,CompletableFuture.
Interrupt: cách duy nhất để dừng thread một cách lịch sự
Java không có cách an toàn để “giết” thread: Thread.stop() đã bị khoá hẳn vì có thể bỏ dở giữa chừng và làm hỏng dữ liệu. Thay vào đó là hợp tác: A gọi b.interrupt() để bật cờ interrupt của B; B tự kiểm tra cờ và tự dừng.
| B đang làm gì | Chuyện gì xảy ra |
|---|---|
Chặn trong sleep, wait, join, BlockingQueue.take/poll… |
Method ném InterruptedException và xoá cờ |
| Đang tính toán | Không gì cả, tới khi B tự kiểm tra Thread.currentThread().isInterrupted() |
I/O cổ điển trên socket (InputStream.read) |
Không phản ứng; phải đóng socket hoặc đặt timeout |
Mẫu worker làm đúng:
import java.util.concurrent.*;
public class Interruption {
static void pollQueue(BlockingQueue<String> queue) {
while (!Thread.currentThread().isInterrupted()) {
try {
String job = queue.poll(1, TimeUnit.SECONDS);
if (job != null) System.out.println("processing " + job);
} catch (InterruptedException e) {
// sleep/poll/wait xoá cờ interrupt khi ném exception -> bật lại
Thread.currentThread().interrupt();
System.out.println("interrupted, cleaning up");
}
}
System.out.println("worker exits, flag = " + Thread.currentThread().isInterrupted());
}
public static void main(String[] args) throws Exception {
BlockingQueue<String> queue = new LinkedBlockingQueue<>();
Thread worker = new Thread(() -> pollQueue(queue), "poller");
worker.start();
queue.put("job-1");
Thread.sleep(200);
worker.interrupt();
worker.join(2000);
System.out.println("worker state = " + worker.getState());
}
}
// processing job-1
// interrupted, cleaning up
// worker exits, flag = true
// worker state = TERMINATED
Bài tập
Bài 1: Đoán output và trạng thái
Đề (diễn đạt lại): cho một đoạn code tạo thread, gọi run(), rồi start(), rồi start() lần nữa sau join(); in tên thread trong task và trạng thái thread ở từng bước. Đoán output.
Lời giải Bài 1
Chính là demo StartVsRun ở mục 2. run() in main; start() in worker-1; start() lần hai ném IllegalThreadStateException vì thread đã TERMINATED và một Thread chỉ start được một lần. Trạng thái: trước start() là NEW, sau join() là TERMINATED; ngay sau start() thì không đoán chắc được (xem pitfall ở mục 3).
Ghi nhớ
- Giải thích được process và thread khác nhau ở bộ nhớ, chi phí tạo, cách giao tiếp.
- Phân biệt được concurrency với parallelism, biết khi nào thêm thread vô ích.
- Nói được vì sao
run()không tạo thread mới và vì saostart()lần hai ném exception. - Kể được 6 trạng thái và vì sao thread chờ I/O vẫn là RUNNABLE.
- Biết hai cách xử lý đúng
InterruptedException.
Câu hỏi phỏng vấn
Junior
Process và thread khác nhau thế nào?
Process là chương trình đang chạy với vùng nhớ riêng; thread là luồng thực thi bên trong process, chung heap nhưng có stack riêng.
Thread là đơn vị hệ điều hành lập lịch. Thread rẻ hơn và giao tiếp nhanh hơn (đọc chung object), nhưng vì chung bộ nhớ nên phải đồng bộ cẩn thận.
start() và run() khác nhau thế nào?
start() yêu cầu JVM tạo thread mới rồi gọi run() trên đó; gọi run() trực tiếp chỉ là gọi method trên thread hiện tại.
Gọi run() thì không có gì song song. start() chỉ gọi được một lần cho mỗi object Thread, lần hai ném IllegalThreadStateException.
Runnable và Callable khác nhau thế nào? Vì sao nên dùng thay cho extends Thread?
Callable trả kết quả và được ném checked exception, Runnable thì không; cả hai tách việc cần làm khỏi thread chạy nó.
Callable<V> nộp qua ExecutorService.submit để nhận Future<V>. Vì tách khỏi thread, chúng dùng được với thread pool, virtual thread và không chiếm mất quyền kế thừa class như extends Thread.
Thread trong Java có những trạng thái nào?
Sáu: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; không có RUNNING riêng.
NEW chưa start; RUNNABLE đang chạy hoặc chờ CPU, kể cả chặn trên I/O; BLOCKED chờ vào synchronized; WAITING là wait, join, park không hạn; TIMED_WAITING là sleep và các bản có timeout; TERMINATED đã xong.
Mid
sleep() và wait() khác nhau thế nào?
sleep giữ nguyên lock và gọi ở đâu cũng được; wait phải giữ monitor và nhả monitor trong lúc chờ.
Thread.sleep là static, dừng thread hiện tại. obj.wait() không giữ monitor của obj thì ném IllegalMonitorStateException; nó chờ notify/notifyAll hoặc hết hạn, và phải nằm trong vòng while (!condition) vì có thể bị đánh thức giả (spurious wakeup). Code mới nên dùng BlockingQueue, CountDownLatch, Condition.
Xử lý InterruptedException thế nào cho đúng?
Hoặc ném tiếp, hoặc gọi Thread.currentThread().interrupt() để bật lại cờ rồi dừng việc đang làm.
Method chặn đã xoá cờ khi ném. Nuốt lỗi bằng catch rỗng hoặc chỉ log thì shutdownNow(), Future.cancel(true) không dừng được task.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu trong phỏng vấn |
|---|---|---|---|
| thread | /θrɛd/ | luồng thực thi | “Each incoming request is handled by a thread from Tomcat’s pool.” |
| concurrency | /kənˈkʌrənsi/ | tính đồng thời | “Concurrency is about structure; parallelism is about execution.” |
| parallelism | /ˈpærəlɛlɪzəm/ | tính song song | “On a two-core machine, parallelism is capped at two.” |
| interrupt | /ˌɪntəˈrʌpt/ | ngắt, yêu cầu dừng | “Interruption is cooperative; the task has to check the flag.” |
| context switch | /ˈkɒntɛkst swɪtʃ/ | chuyển ngữ cảnh giữa các thread | “Adding more threads than cores to CPU-bound work only adds context switches.” |
| I/O-bound / CPU-bound | /ˌaɪˈoʊ baʊnd/ | bị giới hạn bởi I/O / bởi CPU | “Our workload is I/O-bound, so threads spend most of their time waiting on the database.” |
| lifecycle | /ˈlaɪfˌsaɪkəl/ | vòng đời | “A thread’s lifecycle goes from NEW through RUNNABLE to TERMINATED.” |
| blocking call | /ˈblɒkɪŋ kɔːl/ | lời gọi chặn | “Future.get() is a blocking call, so I always pass a timeout.” |
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.