Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.
Thread trong Java: tạo thread, vòng đời và interrupt
1Process và thread
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, mỗi thread có stack riêng.
Process
Thread
Bộ nhớ
Riêng, tách biệt
Chung heap, stack riêng
Chi phí tạo
Lớn
~1 MB stack + OS thread
Giao tiếp
IPC: socket, pipe
Chung object trên heap
2Concurrency và khi nào thread giúp
Concurrency: nhiều việc dở dang cùng lúc (cấu trúc). Parallelism: chạy thật cùng lúc trên nhiều core. Server 2 core, 200 request: parallelism tối đa là 2.
I/O bound (DB, HTTP): thread ngồi chờ, nhiều thread có lợi
CPU bound: quá số core chỉ thêm context switch
Giữ phản hồi: tách việc chậm như gửi email
3Runnable, Callable và start
Viết task là Runnable (không kết quả) hoặc Callable (trả kết quả qua Future), để executor chọn thread. Chỉ start() mới tạo thread mới.
Thread t = new Thread(task, "worker-1");
t.run(); // chạy trên main, không có thread mới
t.start(); // JVM tạo thread mới, gọi run()
t.join();
t.start(); // IllegalThreadStateException
4Sáu trạng thái của thread
getState() trả một trong 6 giá trị. Không có RUNNING: đang chạy hay chờ CPU đều là RUNNABLE; BLOCKED chỉ dành cho synchronized.
flowchart TD
N["NEW"] -->|start| R["RUNNABLE"]
R -->|"synchronized bị giữ"| B["BLOCKED"]
R -->|"wait, join, park"| W["WAITING"]
R -->|"sleep, join(ms)"| T["TIMED_WAITING"]
B --> R
W --> R
T --> R
R -->|"run xong"| X["TERMINATED"]
5Dừng thread bằng interrupt
Không có cách an toàn để giết thread. interrupt() chỉ bật cờ; thread kia tự kiểm tra và tự dừng. Method chặn ném InterruptedException và xoá cờ.
Cách 1: khai báo throws InterruptedException
Cách 2: gọi Thread.currentThread().interrupt() rồi thoát
I/O socket cổ điển không phản ứng: đóng socket, đặt timeout
sleep giữ lock, wait nhả monitor
💡 Ghi nhớ
Thread chung heap, mỗi thread có stack riêng.
Thread chờ I/O vẫn báo RUNNABLE trong thread dump.
Thread chờ ReentrantLock hiện WAITING, không phải BLOCKED.
Future.get() ở production luôn dùng bản có timeout.
⭐ Điểm phỏng vấn
Tự trả lời trước, rồi bấm từng câu để xem đáp án.
start() khác run()?
start tạo thread mới; run chỉ gọi method.
Thread có mấy trạng thái?
Sáu, không có RUNNING riêng.
Xử lý InterruptedException thế nào?
Ném tiếp hoặc bật lại cờ interrupt.
Xong phần tự kiểm tra, bài này đã được đánh dấu đã học ✓
⚠️ Lỗi thường gặp
Bắt InterruptedException rồi chỉ log: shutdownNow() không dừng được task.
Tin getState() ngay sau start() chắc chắn là RUNNABLE.
Dùng Thread.sleep để đồng bộ thay vì CountDownLatch, join().
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.
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 main chạy method main, 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 Threadclass 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:
main in 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 3 in trước download 3 dù download start trước). Đừng dựa vào nó; muốn chờ thì dùng join() (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 mainresize 3 on t-resizedownload 3 on t-downloaddownload 2 on t-downloadresize 2 on t-resizedownload 1 on t-downloadresize 1 on t-resizeboth 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>:
Ghép nhiều bước bất đồng bộ thì dùng CompletableFuture; Future thuần chỉ có get() chặn. Cách nối bước, gộp kết quả, xử lý lỗi và timeout của nó có ở phần 4.
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”.
BLOCKED chỉ dành cho synchronized. Thread chờ ReentrantLock hiện WAITING (lock dùng LockSupport.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 khi join trả về (happens-before, xem phần 2).
obj.wait() / obj.notifyAll(): chờ/đánh thức cấp thấp, phải giữ monitor của obj; wait()nhả monitor khi chờ. Code mới dùng BlockingQueue, 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 InterruptedExceptionvà 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ì sao start() 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.