Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.
ExecutorService, thread pool và virtual thread trong Java
1Vì sao cần thread pool
Tạo một OS thread cho mỗi việc vừa tốn (stack ~1 MB), vừa không giới hạn. Thread pool giữ sẵn vài thread và một hàng đợi task; ExecutorService là interface để nộp task và quản lý vòng đời.
execute(runnable): bắn và quên
submit(callable): lấy kết quả qua Future
invokeAll(tasks, 2, SECONDS): chờ tất cả, có hạn chót
2Thứ tự xử lý một task
Pool chỉ vượt core khi hàng đợi đã đầy. Hàng đợi không giới hạn thì max và rejection policy không bao giờ có tác dụng.
flowchart TD
A["Nộp task"] --> B{"threads < core?"}
B -->|có| C["Tạo thread mới"]
B -->|không| D{"Hàng đợi còn chỗ?"}
D -->|có| E["Vào hàng đợi"]
D -->|không| F{"threads < max?"}
F -->|có| G["Tạo thêm thread"]
F -->|không| H["Rejection policy"]
3Cấu hình pool cho production
Tự khai báo ThreadPoolExecutor với hàng đợi có giới hạn, rejection policy có chủ đích, đặt tên thread. Tắt pool: shutdown() → awaitTermination có hạn → shutdownNow().
Quyết định
Gợi ý
Số thread CPU bound
≈ số core
Số thread I/O bound
core × (1 + chờ/tính)
Quá tải: báo lỗi
AbortPolicy, trả 503
Quá tải: back-pressure
CallerRunsPolicy
4Virtual thread
Thread do JVM quản lý, rẻ tới mức tạo hàng triệu. Chặn chờ I/O thì JVM tháo nó khỏi carrier. Tăng throughput cho việc chờ I/O, không giảm latency.
10.000 việc chờ 1 giây
Thời gian
Pool 200 platform thread
50.210 ms
Virtual thread mỗi task
1.050 ms
1.000 task synchronized, JDK 21
10.394 ms (pinning)
5ThreadLocal trong pool
Thread trong pool không chết sau mỗi task, nên giá trị không remove() sang task kế tiếp. set ở đâu thì remove() trong finally ở đó.
Đừng pool virtual thread; giới hạn bằng Semaphore.
Tách pool theo loại việc (bulkhead).
Java 24 gỡ pinning với synchronized (JEP 491).
Số thread bị chặn bởi tài nguyên hẹp nhất phía sau.
⭐ Điểm phỏng vấn
Tự trả lời trước, rồi bấm từng câu để xem đáp án.
Khi nào pool tạo thêm thread vượt core?
Chỉ khi hàng đợi đã đầy.
Virtual thread có làm code nhanh hơn?
Không, chỉ tăng throughput cho việc chờ I/O.
Chọn số thread thế nào?
Công thức khởi đầu, chặn theo DB, đo dưới tải.
Xong phần tự kiểm tra, bài này đã được đánh dấu đã học ✓
⚠️ Lỗi thường gặp
newFixedThreadPool: hàng đợi không giới hạn, quá tải là OOM im lặng.
submit() không gọi get(): exception bị nuốt.
Quên ThreadLocal.remove(): request ẩn danh bị ghi audit tên người khác.
🛠 Tự tay làm
Tự viết phần lõi, chưa nhờ agent. Tick từng bước khi xong.
Nhiệm vụ: Chạy 10.000 lần chuyển tiền cho MiniWallet (Phase 0, package miniwallet.core.exec), mỗi lần hỏi ngân hàng giả mất 100 ms: so fixed pool với virtual thread, rồi làm thread bị ghim.
Tự viết:BankCheck, TransferBatch.run, ExecDemo · Được nhờ agent: đo thời gian.
Tạo interface BankCheck với boolean verify(String accountId) và một bản giả gọi Thread.sleep(100).
Viết TransferBatch.run(ExecutorService pool, int n, boolean lockSender): submit n task, chờ mọi Future, trả số lần được duyệt.
Viết ExecDemo <mode> <n>: mở ExecutorService bằng try-with-resources, in wall time và ThreadMXBean.getPeakThreadCount().
Chạy fixed (newFixedThreadPool(200)) và virtual (newVirtualThreadPerTaskExecutor()) với n = 10.000; tự tính trước con số 5 giây.
Bật lockSender: bọc verify trong synchronized (sender), chạy trên JDK 21. Virtual thread ngủ trong monitor bị ghim vào carrier, máy 10 core chỉ gọi song song 10 lần: 1.000 lần mất 10,367 ms, 10.000 lần mất 103,436 ms, -Djdk.tracePinnedThreads=short in reason:MONITOR. Trên JDK 25 (JEP 491), 1.000 lần chỉ 128 ms.
Agent hỏi lại bạn
Vì sao fixed pool 200 thread mất khoảng 5 giây? Tăng lên 10.000 thread thì sao?
Trên Java 21, thay synchronized bằng gì để hết ghim?
Ngân hàng chỉ chịu 50 kết nối: giới hạn virtual thread bằng gì?
Xong bài thực hành. Giờ dán 3 câu hỏi cuối cho agent để nó chất vấn code của bạn.
Tomcat, @Async, @Scheduled, Kafka consumer đều chạy trên thread pool, và phần lớn sự cố thread ở production (OOM vì hàng đợi phình, app tắt không xong, người A thấy dữ liệu người B) nằm ở cấu hình pool. Đọc xong, bạn cấu hình được ThreadPoolExecutor, chọn số thread, tắt pool gọn, và biết khi nào dùng virtual thread. Nên đọc phần 1 (interrupt) và phần 2 (race condition, happens-before) trước; mọi demo đã chạy trên JDK 21.
1. ExecutorService và thread pool
Ý chính: thread pool giữ sẵn một số thread và một hàng đợi task, để không phải tạo một OS thread cho mỗi việc. ExecutorService là interface để nộp task và quản lý vòng đời pool.
new Thread() cho mỗi việc có ba vấn đề:
Tốn kém: tạo/huỷ OS thread cần stack ~1 MB và system call.
Không giới hạn: 1 vạn request = 1 vạn thread = hết bộ nhớ hoặc vượt giới hạn OS.
Không có chỗ quản lý chung: đặt tên, bắt lỗi, tắt gọn.
ExecutorService pool = ...;pool.execute(runnable); // bắn và quênFuture<T> f = pool.submit(callable); // lấy kết quả qua FutureList<Future<T>> all = pool.invokeAll(tasks, 2, TimeUnit.SECONDS); // chờ tất cả, có hạn chót
Task nộp vào là lambda của Runnable hay Callable, hai functional interface; vì sao một lambda gán được cho chúng có ở bài Lambda và Stream API.
ThreadPoolExecutor: các tham số thật sự
Ý chính: các factory Executors.newXxx() chỉ là lối tắt tạo ThreadPoolExecutor. Ở production nên tự khai báo, và hiểu đúng thứ tự pool xử lý một task.
ThreadPoolExecutor pool = new ThreadPoolExecutor( 2, 4, // corePoolSize = 2, maximumPoolSize = 4 30, TimeUnit.SECONDS, // thread ngoài core rảnh 30s thì bị huỷ new ArrayBlockingQueue<>(2), // hàng đợi CÓ giới hạn named("report"), // ThreadFactory: đặt tên thread để đọc log/thread dump new ThreadPoolExecutor.AbortPolicy()); // khi đầy: ném RejectedExecutionException
Thứ tự khi nộp một task (chỗ nhiều người hiểu sai):
Số thread < core → tạo thread mới, kể cả khi thread khác đang rảnh.
Đủ core → đưa vào hàng đợi.
Hàng đợi đầy → tạo thêm thread tới max.
Đủ max và hàng đợi đầy → gọi rejection policy.
flowchart TD
A[Nộp task] --> B{threads < core?}
B -- có --> C[Tạo thread mới]
B -- không --> D{Hàng đợi còn chỗ?}
D -- có --> E[Vào hàng đợi]
D -- không --> F{threads < max?}
F -- có --> G[Tạo thêm thread]
F -- không --> H[Rejection policy]
Demo 7 task và ThreadFactory đặt tên, bắt exception
Phần đặt tên thread và bắt exception cho task nộp bằng execute:
static ThreadFactory named(String prefix) { AtomicInteger n = new AtomicInteger(); return r -> { Thread t = new Thread(r, prefix + "-" + n.incrementAndGet()); t.setUncaughtExceptionHandler((th, ex) -> System.out.println("uncaught in " + th.getName() + ": " + ex.getMessage())); return t; };}
Rejection policy
Ý chính: rejection policy quyết định làm gì khi pool và hàng đợi đều đầy. Mặc định là ném lỗi; CallerRunsPolicy cho back-pressure.
Policy
Khi pool và hàng đợi đầy
Dùng khi
AbortPolicy (mặc định)
Ném RejectedExecutionException cho người nộp
Muốn báo lỗi rõ ràng: trả 503/429, ghi lại để retry
CallerRunsPolicy
Thread nộp task tự chạy task đó
Muốn back-pressure (áp lực ngược): người nộp bị chậm lại nên nộp ít đi
DiscardPolicy
Lặng lẽ bỏ task mới
Hầu như không nên; mất việc mà không ai biết
DiscardOldestPolicy
Bỏ task cũ nhất trong hàng đợi, nộp lại task mới
Dữ liệu chỉ cần bản mới nhất (vd. vị trí, giá)
Chọn số thread cho pool
Ý chính: không có con số đúng cho mọi trường hợp. Dùng công thức để bắt đầu, chặn theo tài nguyên phía sau, rồi đo lại dưới tải thật.
CPU bound: số thread ≈ số core (hoặc +1). Thêm nữa chỉ tăng context switch.
I/O bound: số thread ≈ số core × (1 + thời gian chờ / thời gian tính). 8 core, chờ DB 90 ms, tính 10 ms: 8 × (1 + 9) = 80.
Định luật Little: số việc đồng thời = throughput × độ trễ. 400 request/s, mỗi request 0,25 s → khoảng 100 việc đồng thời. Cách dùng định luật này để ước lượng thread, connection, server: Ước lượng back-of-the-envelope.
Giới hạn phía sau: 200 thread gọi DB nhưng pool connection (HikariCP) chỉ có 20 thì 180 thread ngồi chờ (xem ORM và JPA về connection pool).
“Đo lại dưới tải thật” nghĩa là load test có mục tiêu từ SLO, nhìn p99 và độ bão hoà của pool; cách làm cho đúng có ở Performance test.
Tách pool theo loại việc (bulkhead, như vách ngăn khoang tàu): một pool cho payment, một cho email. Payment chậm chỉ làm cạn pool của nó. @Scheduled của Spring mặc định chỉ có một thread, xem bài Cron job.
Ở hàng triệu task mỗi giây, chính hàng đợi giữa các thread thành nút thắt (ArrayBlockingQueue dùng một ReentrantLock cho cả put lẫn take). LMAX Disruptor thay nó bằng ring buffer cấp phát sẵn, CAS và padding chống false sharing; so sánh và khi nào đáng dùng ở Hệ thống liveness: timing wheel và LMAX Disruptor.
Tắt pool đúng cách
Ý chính: thread trong pool là non-daemon, quên tắt thì JVM không thoát. Tắt theo ba bước: shutdown(), chờ có hạn, hết hạn thì shutdownNow().
static void shutdownGracefully(ExecutorService pool) { pool.shutdown(); // ngừng nhận task mới, task cũ vẫn chạy hết try { if (!pool.awaitTermination(30, TimeUnit.SECONDS)) { List<Runnable> neverRan = pool.shutdownNow(); // interrupt task đang chạy, trả lại task chưa chạy log.warn("{} tasks dropped on shutdown", neverRan.size()); if (!pool.awaitTermination(10, TimeUnit.SECONDS)) { log.error("pool did not terminate"); } } } catch (InterruptedException e) { pool.shutdownNow(); Thread.currentThread().interrupt(); }}
shutdown(): không nhận task mới (nộp thêm bị reject), task trong hàng đợi vẫn chạy.
shutdownNow(): interrupt thread đang chạy, trả về task chưa chạy. Task chỉ dừng thật nếu tôn trọng interrupt (xem phần 1, mục 4).
Spring và try-with-resources (Java 19)
Trong Spring, executor là bean (ThreadPoolTaskExecutor) nên được tắt cùng context. Bật spring.task.execution.shutdown.await-termination=true và đặt await-termination-period để task đang chạy có thời gian hoàn tất khi deploy.
2. Virtual thread (Java 21)
Ý chính: virtual thread là thread do JVM quản lý, rẻ tới mức tạo hàng triệu cái được. Khi nó chặn chờ I/O, JVM tháo nó khỏi OS thread để OS thread chạy việc khác, nên code chặn tuần tự vẫn phục vụ được rất nhiều kết nối.
Platform thread (thread truyền thống) bọc một OS thread: ~1 MB stack, tạo chậm, OS chịu vài nghìn cái. Thread chờ DB 100 ms vẫn giữ chỗ OS thread, nên người ta từng chuyển sang reactive (WebFlux), đổi lại code khó đọc, khó debug.
Virtual thread (JEP 444, chính thức từ Java 21):
Stack nằm trên heap, ban đầu chỉ vài trăm byte tới vài KB.
Chạy trên một nhóm nhỏ carrier thread (thread nền chở virtual thread; một ForkJoinPool, mặc định bằng số core).
Gặp thao tác chặn (sleep, socket, BlockingQueue, ReentrantLock), JVM unmount (tháo) nó khỏi carrier, cất stack lên heap. I/O xong thì gắn lại vào một carrier nào đó chạy tiếp.
import java.time.Duration;import java.util.concurrent.*;import java.util.stream.IntStream;public class VirtualThreads { static int callRemote(int i) { try { Thread.sleep(Duration.ofSeconds(1)); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } return i; } static long run(ExecutorService executor, int tasks) throws Exception { long start = System.nanoTime(); try (executor) { var futures = IntStream.range(0, tasks).mapToObj(i -> executor.submit(() -> callRemote(i))).toList(); for (var f : futures) f.get(); } return Duration.ofNanos(System.nanoTime() - start).toMillis(); } public static void main(String[] args) throws Exception { int tasks = 10_000; System.out.println("platform pool(200): " + run(Executors.newFixedThreadPool(200), tasks) + " ms"); System.out.println("virtual per task : " + run(Executors.newVirtualThreadPerTaskExecutor(), tasks) + " ms"); }}// platform pool(200): 50210 ms// virtual per task : 1050 ms
10.000 việc chờ I/O 1 giây: pool 200 platform thread cần 50 lượt (50 s); 10.000 virtual thread chạy cùng lúc, xong ~1 s. Tạo bằng Thread.ofVirtual().start(r), Thread.startVirtualThread(r) hoặc Executors.newVirtualThreadPerTaskExecutor(). Spring Boot 3.2+: spring.threads.virtual.enabled=true để Tomcat và @Async dùng virtual thread.
Virtual thread không làm code nhanh hơn: nó tăng throughput cho việc chờ I/O, không giảm latency từng việc, và không giúp việc CPU bound. Các thay đổi khác của Java 17–21 đáng biết khi nâng cấp (record, sealed, pattern matching, javax → jakarta) có ở bài Java 17 và 21.
Pinning
Ý chính: virtual thread bị ghim (pinned) khi không tháo khỏi carrier được lúc chặn: trong khối synchronized (Java 21–23) hoặc trong frame native/JNI. Mỗi lần chặn khi bị ghim giữ chặt một carrier, mà carrier chỉ bằng số core.
static void blockingCallInsideSynchronized() { Object perTaskMonitor = new Object(); synchronized (perTaskMonitor) { // Java 21-23: virtual thread bị ghim vào carrier try { Thread.sleep(Duration.ofMillis(100)); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }}static void blockingCallInsideReentrantLock() { ReentrantLock lock = new ReentrantLock(); lock.lock(); try { try { Thread.sleep(Duration.ofMillis(100)); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } finally { lock.unlock(); }}// 1.000 virtual thread, máy 10 core, JDK 21:// synchronized : 10394 ms (chỉ 10 cái chạy cùng lúc: 100 lượt x 100 ms)// ReentrantLock : 108 ms
Mỗi task dùng monitor riêng, không ai tranh chấp, vậy mà bản synchronized chậm gần 100 lần, chỉ vì 10 carrier bị ghim. Cách sửa: thay synchronized bao quanh I/O bằng ReentrantLock, hoặc nâng JDK.
Tìm chỗ bị ghim trên JDK 21–23
Chạy với -Djdk.tracePinnedThreads=short để JVM in chỗ bị ghim (reason:MONITOR, kèm dòng code), hoặc bật sự kiện JFR jdk.VirtualThreadPinned.
3. ThreadLocal và rò rỉ trong thread pool
Ý chính:ThreadLocal<T> cho mỗi thread một bản giá trị riêng. Thread trong pool không chết sau mỗi task, nên giá trị không remove() sẽ sang task kế tiếp chạy trên đúng thread đó.
Framework dùng nó rất nhiều: SecurityContextHolder (user đang đăng nhập), TransactionSynchronizationManager (transaction hiện tại), MDC của logging (trace id).
import java.util.concurrent.*;public class ThreadLocalLeak { static final ThreadLocal<String> CURRENT_USER = new ThreadLocal<>(); static void handle(String user) { if (user != null) CURRENT_USER.set(user); // request ẩn danh thì không set System.out.println("request by " + user + " -> audit as " + CURRENT_USER.get()); } static void handleSafely(String user) { try { if (user != null) CURRENT_USER.set(user); System.out.println("request by " + user + " -> audit as " + CURRENT_USER.get()); } finally { CURRENT_USER.remove(); } } public static void main(String[] args) throws Exception { try (ExecutorService pool = Executors.newSingleThreadExecutor()) { pool.submit(() -> handle("alice")).get(); pool.submit(() -> handle(null)).get(); // thread cũ vẫn mang "alice" System.out.println("--- with remove() ---"); pool.submit(() -> handleSafely("bob")).get(); pool.submit(() -> handleSafely(null)).get(); } }}// request by alice -> audit as alice// request by null -> audit as alice <- request ẩn danh bị ghi là alice// --- with remove() ---// request by bob -> audit as bob// request by null -> audit as null
Mặt kia là ngữ cảnh bị mất khi việc nhảy sang thread khác: trace id trong MDC và span OpenTelemetry nằm trong ThreadLocal, nên task đẩy sang executor tự tạo ghi log thiếu trace id và sinh span không có cha.
Những chỗ context bị mất và cách mang theo
Bài Distributed tracing với OpenTelemetry, mục “Context bị mất ở đâu”, liệt kê các chỗ đó (ExecutorService, CompletableFuture.supplyAsync, @Async, message broker, job đọc outbox) và cách mang context theo bằng Context.current().wrap(...) hoặc Context.taskWrapping(executor).
Bài tập
Bài 1: Lấy giá song song có giới hạn và hạn chót
Đề: có 100 mã sản phẩm và hàm fetchPrice(id) gọi API nhà cung cấp, mất 100–300 ms, thỉnh thoảng lỗi, rất hiếm khi treo. Nhà cung cấp chỉ cho tối đa 10 request đồng thời. Lấy giá cả 100 mã, cả lô phải xong trong 4 giây; trả về danh sách thành công và danh sách lỗi (kèm lý do).
Lời giải Bài 1: virtual thread + Semaphore + invokeAll có timeout
record Result(Map<Integer, Long> prices, Map<Integer, String> failures) {}static Result fetchAll(List<Integer> ids, int maxConcurrent, long timeoutMs) throws InterruptedException { Semaphore permits = new Semaphore(maxConcurrent); List<Callable<Long>> tasks = ids.stream().<Callable<Long>>map(id -> () -> { permits.acquire(); try { return fetchPrice(id); } finally { permits.release(); } }).toList(); Map<Integer, Long> prices = new TreeMap<>(); Map<Integer, String> failures = new TreeMap<>(); try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) { // invokeAll có timeout: hết giờ thì cancel(true) các task chưa xong List<Future<Long>> futures = executor.invokeAll(tasks, timeoutMs, TimeUnit.MILLISECONDS); for (int i = 0; i < ids.size(); i++) { Future<Long> f = futures.get(i); switch (f.state()) { // Java 19+ case SUCCESS -> prices.put(ids.get(i), f.resultNow()); case FAILED -> failures.put(ids.get(i), f.exceptionNow().getMessage()); case CANCELLED -> failures.put(ids.get(i), "timeout"); case RUNNING -> throw new AssertionError("invokeAll returns only finished futures"); } } } return new Result(prices, failures);}// ok=94 failed=6 maxInFlight=10 took=4006 ms// {17=supplier error for 17, 34=supplier error for 34, 42=timeout, 51=..., 68=..., 85=...}
Mỗi request một virtual thread; Semaphore(10) là giới hạn đồng thời thật (đo được tối đa 10 request cùng lúc).
invokeAll có timeout trả về khi mọi task xong hoặc hết hạn; task chưa xong bị cancel(true) nên thread bị interrupt và thoát khỏi sleep.
Future.state(), resultNow(), exceptionNow() (Java 19) phân loại kết quả không cần try/catch. Một lỗi không làm hỏng cả lô.
Dùng platform thread thì đổi sang Executors.newFixedThreadPool(10) và bỏ semaphore, vì kích thước pool lúc đó chính là giới hạn.
Bài 2: Tính kích thước pool
Đề: service chạy trên máy 8 core. (a) Job resize ảnh, thuần CPU. (b) Mỗi request gọi DB mất 40 ms và xử lý 10 ms CPU; HikariCP có 30 connection. Chọn số thread.
Lời giải Bài 2
(a) CPU bound: 8 thread (hoặc 9). Nhiều hơn chỉ thêm context switch.
(b) Theo công thức: 8 × (1 + 40/10) = 40 thread. Nhưng chỉ có 30 connection, thread thứ 31 trở đi chỉ ngồi chờ; đặt khoảng 30 thread cho phần gọi DB, hàng đợi có giới hạn, và đo lại dưới tải thật (CPU, thời gian chờ connection trong metric của Hikari, p99 latency). Muốn nhiều hơn thì tăng connection pool, nhưng nó cũng có giới hạn phía DB.
Ghi nhớ
Kể được 4 bước ThreadPoolExecutor xử lý một task, và vì sao newFixedThreadPool không bao giờ reject.
Biết khi nào chọn AbortPolicy, khi nào CallerRunsPolicy, và tính kích thước hàng đợi từ SLA.
Tính được số thread cho việc CPU bound và I/O bound, và chỉ ra tài nguyên phía sau đang chặn.
Giải thích được virtual thread tăng gì, không tăng gì, vì sao không pool nó, và pinning là gì.
Biết vì sao ThreadLocal rò dữ liệu trong pool và cách dọn đúng.
Câu hỏi phỏng vấn
Junior
Vì sao dùng thread pool thay vì new Thread() cho mỗi việc?
Vì tạo OS thread tốn kém và không có giới hạn; pool tái sử dụng một số thread cố định và cho một chỗ quản lý chung.
Tạo/huỷ OS thread cần stack khoảng 1 MB và system call; tải tăng đột biến thì số thread tăng tới khi hết bộ nhớ. Pool có hàng đợi và giới hạn rõ ràng, và là chỗ duy nhất để đặt tên thread, bắt lỗi, tắt gọn khi app dừng. Riêng virtual thread (Java 21) thì rẻ, không cần pool; khi đó giới hạn đồng thời bằng Semaphore.
Executor, ExecutorService và ThreadPoolExecutor khác nhau thế nào?
Executor là interface một method “chạy giùm task này”; ExecutorService thêm quản lý vòng đời và kết quả; ThreadPoolExecutor là class cài đặt thật sự quản lý các thread.
Executor.execute(Runnable): tách việc nộp task khỏi việc chạy nó (thread nào, lúc nào).
ExecutorService mở rộng Executor: submit trả Future, invokeAll/invokeAny, shutdown/shutdownNow/awaitTermination, và từ Java 19 là AutoCloseable.
ThreadPoolExecutor cài đặt ExecutorService với core/max thread, hàng đợi, keep-alive, ThreadFactory, rejection policy. Các method Executors.newFixedThreadPool… chỉ là cách dựng sẵn nó (trừ newVirtualThreadPerTaskExecutor và ForkJoinPool).
Code nghiệp vụ nên phụ thuộc vào ExecutorService (hoặc Executor), còn chỗ cấu hình mới biết là ThreadPoolExecutor.
Mid
execute() và submit() của ExecutorService khác nhau thế nào khi task ném exception?
execute để exception làm chết thread và tới UncaughtExceptionHandler; submit cất exception vào Future, chỉ lộ ra khi gọi get().
execute(Runnable) không trả gì; handler mặc định in ra stderr và pool tạo thread thay thế. submit(...) trả Future; exception lộ ra dưới dạng ExecutionException khi get(). Không ai gọi get() thì lỗi mất hẳn.
Bạn chọn số thread cho một thread pool như thế nào?
CPU bound ≈ số core; I/O bound ≈ số core × (1 + chờ/tính); rồi chặn theo tài nguyên phía sau và đo lại.
Có thể dùng định luật Little (đồng thời = throughput × độ trễ). Tài nguyên phía sau gồm connection pool DB, rate limit của API; đo dưới tải thật. Tách pool theo loại việc (bulkhead) để một phụ thuộc chậm không kéo cả app.
shutdown() và shutdownNow() khác nhau thế nào?
shutdown() ngừng nhận task mới nhưng chạy hết task đang chạy và trong hàng đợi; shutdownNow() interrupt thread đang chạy và trả về task chưa chạy.
Task chỉ dừng thật nếu tôn trọng interrupt. Cả hai đều không chờ; muốn chờ thì gọi awaitTermination(timeout). Mẫu chuẩn: shutdown(), chờ có hạn, hết hạn thì shutdownNow() và chờ thêm một chút.
Thread rảnh trong pool có tốn CPU không? Vì sao vẫn giữ core thread khi không có việc?
Không tốn CPU: worker rảnh đang chặn ở queue.take() (trạng thái WAITING), OS không lập lịch cho nó. Nó chỉ tốn bộ nhớ stack và một thread của OS.
Giữ core thread để request kế tiếp không phải trả giá tạo thread, và độ trễ ổn định khi tải lên đột ngột.
Thread vượt corePoolSize tự chết sau keepAliveTime rảnh. Muốn cả core thread cũng chết khi rảnh lâu (job chạy thưa thớt), bật allowCoreThreadTimeOut(true).
Cái giá thật của pool quá lớn là bộ nhớ (mỗi platform thread có stack, mặc định khoảng 1 MB vùng nhớ dành sẵn) và context switch khi chúng cùng có việc, không phải lúc rảnh.
Pool không shutdown() thì worker (thread non-daemon) giữ JVM không thoát được: đó là rò thread, không phải rò heap.
Senior
Vì sao không nên dùng Executors.newFixedThreadPool hay newCachedThreadPool ở production?
Fixed dùng hàng đợi không giới hạn nên quá tải là OOM im lặng; Cached không giới hạn số thread nên tải đột biến sinh hàng nghìn thread.
newFixedThreadPool và newSingleThreadExecutor dùng LinkedBlockingQueue không giới hạn: không back-pressure, maximumPoolSize và rejection policy không bao giờ có tác dụng (pool chỉ vượt core khi hàng đợi đầy). newCachedThreadPool có max là Integer.MAX_VALUE. Nên tự tạo ThreadPoolExecutor với hàng đợi có giới hạn, rejection policy có chủ đích (Abort để fail fast, CallerRuns để back-pressure), ThreadFactory đặt tên, và metric cho kích thước hàng đợi và số task bị từ chối.
Virtual thread giúp gì, không giúp gì, và có những bẫy nào?
Tăng throughput cho việc I/O bound đồng thời cao mà vẫn viết code chặn tuần tự; không giúp CPU bound, không giảm latency từng request.
JVM tháo virtual thread khỏi carrier khi chặn. Bẫy:
Pinning khi chặn trong synchronized (Java 21–23, đã gỡ ở 24 qua JEP 491) hoặc native code.
Không được pool virtual thread; phải giới hạn đồng thời bằng Semaphore để không đè sập DB/API phía sau.
ThreadLocal nặng nhân lên theo số thread; cân nhắc ScopedValue.
ThreadLocal gây rò rỉ trong thread pool như thế nào?
Thread trong pool được tái sử dụng, nên giá trị đã set mà không remove sang task kế tiếp: sai dữ liệu và rò bộ nhớ.
Request sau thấy user/tenant của request trước; value là strong reference trong ThreadLocalMap của thread sống mãi (ở app server còn giữ classloader). Luôn remove() trong finally; khi chuyển ngữ cảnh (MDC, SecurityContext) sang executor khác thì dùng TaskDecorator copy vào và dọn sau.
Từ vựng tiếng Anh
Term
Phát âm
Nghĩa
Ví dụ câu trong phỏng vấn
graceful shutdown
/ˈɡreɪsfəl ˈʃʌtdaʊn/
tắt êm, cho việc đang làm hoàn tất
“On SIGTERM we drain the executor with a graceful shutdown.”
back-pressure
/bæk ˈprɛʃər/
áp lực ngược, làm chậm bên gửi
“CallerRunsPolicy gives you back-pressure for free.”
bounded queue
/ˈbaʊndɪd kjuː/
hàng đợi có giới hạn
“A bounded queue turns overload into a visible rejection instead of an OOM.”
reject
/rɪˈdʒɛkt/
từ chối
“When the queue is full, the executor rejects the task.”
pinning
/ˈpɪnɪŋ/
bị ghim (virtual thread không nhả carrier)
“Blocking inside synchronized caused pinning on Java 21.”
carrier thread
/ˈkæriər θrɛd/
thread nền chở virtual thread
“Virtual threads are mounted on a small pool of carrier threads.”
throughput
/ˈθruːpʊt/
lưu lượng xử lý
“Virtual threads raise throughput, not per-request latency.”
leak
/liːk/
rò rỉ
“Forgetting remove() on a ThreadLocal leaks data across requests.”
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.