Java Virtual Threads: code blocking mà vẫn gánh trăm nghìn request

- Published on
- 11 mins read
Mở thread dump của một service Spring Boot đang tải cao, phần lớn thread nằm ở cùng một kiểu trạng thái: đứng chờ. Chờ database trả kết quả query, chờ HTTP từ service bên cạnh, chờ Redis. CPU thì rảnh, còn request mới xếp hàng ngoài cửa vì thread pool đã hết chỗ.
Với mô hình thread-per-request truyền thống của Java, mỗi lúc đứng chờ như vậy là một OS thread (nặng cỡ 1MB stack) bị giữ khư khư. Muốn đẩy throughput lên, trước đây bạn phải bước sang thế giới bất đồng bộ (CompletableFuture, WebFlux/Reactive), đổi lấy những đoạn callback rối rắm và stack trace đứt đoạn rất khó debug.
Java 21 trả lời bằng Virtual Threads (chính thức qua JEP 444). Bạn vẫn viết code đồng bộ (blocking) tuần tự từ trên xuống, còn JVM tự gỡ luồng đang chờ I/O ra khỏi OS thread để phục vụ hàng chục, hàng trăm nghìn tác vụ đồng thời. Nghe như bữa trưa miễn phí, nhưng nó có vài cái bẫy như pinning hay ThreadLocal mà bạn nên biết trước khi bật trên production.
# concurrency trong Java: mấy cái khó từ trước tới giờ
Trước Java 21, mỗi đối tượng java.lang.Thread bạn tạo ra đều là một platform thread ánh xạ 1:1 với một kernel thread của hệ điều hành: JVM phải gọi xuống OS để cấp phát, OS chịu trách nhiệm lập lịch (scheduling), và mỗi thread giữ cứng một vùng bộ nhớ stack riêng (mặc định khoảng 1MB trên Linux x64, chỉnh qua cờ -Xss).
Khi ứng dụng chỉ chạy vài trăm luồng thì mô hình 1:1 này hoàn toàn ổn. Nhưng hễ tải tăng lên hàng nghìn request đồng thời, ba điểm nghẽn lớn sẽ lộ ra ngay:
Thứ nhất là tốn bộ nhớ và chi phí chuyển ngữ cảnh (context switch): riêng 2.000 platform threads đã giữ chỗ khoảng 2GB địa chỉ ảo cho stack (RAM thật bị chiếm dần theo độ sâu stack, nhưng cộng lại vẫn nặng), chưa kể mỗi lần OS chuyển CPU từ thread này sang thread khác lại tốn hàng nghìn chu kỳ lệnh và làm nguội bộ nhớ đệm (CPU cache). Thứ hai là lãng phí khi chờ I/O (blocking I/O): khi thread gọi JDBC hay đọc socket, nó bị khoá cứng trong trạng thái chờ, ôm nguyên stack và slot trong thread pool mà CPU chẳng chạy lệnh nào. Thứ ba là áp lực phải viết code bất đồng bộ: vì số OS thread có trần (thường chỉ đặt pool vài trăm), muốn gánh hàng chục nghìn kết nối thì dev phải chuyển sang non-blocking I/O (Netty, Reactor), khiến luồng nghiệp vụ bị xé lẻ thành từng mảnh callback.
# virtual threads: lời giải của java 21
Java 21 gỡ mấy nút thắt trên bằng một mô hình thread mới, nhẹ hơn hẳn.
Virtual Threads là thread "ảo", do JVM quản lý chứ không phải hệ điều hành. Nó rẻ hơn threads truyền thống rất nhiều, rẻ tới mức tạo hàng trăm nghìn, thậm chí hàng triệu cái vẫn được.
# cách hoạt động
JVM có một scheduler riêng (mặc định là một ForkJoinPool, số thread bằng số CPU core) gồm vài platform thread gọi là carrier thread. Virtual thread muốn chạy thì được "gắn" (mount) lên một carrier. Khi nó gặp thao tác blocking (chờ socket, Thread.sleep, chờ lock trong java.util.concurrent...), JVM gỡ (unmount) nó ra, cất stack của nó vào heap, và carrier rảnh tay chạy virtual thread khác. Dữ liệu về thì virtual thread được gắn lại lên một carrier bất kỳ để chạy tiếp. (Thời còn là dự án Loom, khái niệm này từng được gọi là "fiber".) Nó có mấy đặc điểm sau:
- Lightweight: stack nằm trên heap dưới dạng object, co giãn theo độ sâu lời gọi thực tế, nên một virtual thread đang nghỉ chỉ tốn cỡ vài trăm byte tới vài KB. Tạo ra cũng rẻ như tạo một object.
- Code blocking, nhưng không giữ OS thread: code trong virtual thread vẫn viết kiểu blocking bình thường (gọi JDBC,
HttpClient.send, đọc socket). Virtual thread có bị block, nhưng thứ bị block chỉ là virtual thread, carrier thread bên dưới được trả lại để làm việc khác. Đây là khác biệt lớn với lập trình bất đồng bộ: bạn không phải đổi cách viết code. - Scalable: số tác vụ đồng thời không còn bị giới hạn bởi số OS thread. Giới hạn chuyển sang chỗ khác: heap, số connection DB, sức chịu của service phía sau.
# lợi ích
Từ cơ chế mount/unmount đó, lợi ích lớn nhất mà Virtual Threads mang lại cho các ứng dụng I/O-bound là tăng vọt throughput mà không làm phức tạp code. Cần phân biệt rõ: virtual thread không có phép màu làm một câu query DB 50ms chạy nhanh thành 5ms (latency của từng request giữ nguyên); cái nó giải quyết là trong 50ms chờ DB đó, vài carrier thread vẫn rảnh tay tiếp nhận thêm hàng chục nghìn request khác thay vì để request mới xếp hàng ngoài cửa chờ thread pool. Lập trình viên viết code tuần tự dễ đọc, stack trace khi văng exception vẫn liền mạch từ đầu tới cuối, còn phần điều phối luồng đã có JVM lo.
# dùng virtual threads trong java 21
Muốn dùng Virtual Threads trong Java 21 thì phải đổi cách tạo và quản lý threads trong ứng dụng. Tin vui là tạo Virtual Thread đơn giản hơn thread thường nhiều.
Tạo Virtual Thread
Tạo một Virtual Thread trong Java 21 bằng Thread.ofVirtual().start():
Thread virtualThread = Thread.ofVirtual().start(() -> {
System.out.println("Virtual thread is running!");
});
virtualThread.join(); // chờ nó chạy xongĐoạn trên tạo một Virtual Thread mới và chạy nó ngay. Virtual thread luôn là daemon thread, nên nếu main kết thúc trước thì JVM tắt luôn, không chờ nó; vì vậy mới có dòng join(). Cách viết ngắn hơn là Thread.startVirtualThread(...). Nó thay được cho cách tạo thread kiểu cũ:
Thread thread = new Thread(() -> {
System.out.println("Real thread is running!");
});
thread.start();Một điểm đáng chú ý: với Virtual Threads, bạn không cần thread pool như khi dùng thread thường. Pool tồn tại vì platform thread đắt, phải tái sử dụng; virtual thread thì rẻ, mỗi task một thread mới rồi bỏ đi là cách dùng đúng. Đừng gom virtual thread vào ThreadPoolExecutor cố định số lượng. Bạn vẫn dùng interface ExecutorService quen thuộc, chỉ là executor bên dưới tạo virtual thread mới cho mỗi task.
Dùng Virtual Threads với ExecutorService
Java 21 cho dùng Virtual Threads với ExecutorService. Tạo một ExecutorService chạy bằng Virtual Threads như sau:
ExecutorService executorService = Executors.newVirtualThreadPerTaskExecutor();
executorService.submit(() -> {
System.out.println("Virtual thread in ExecutorService is running!");
});Với Executors.newVirtualThreadPerTaskExecutor(), mỗi task gửi vào executorService sẽ chạy trên một Virtual Thread mới, quản lý concurrency nhàn hơn hẳn.
# ví dụ thực tế
Xem một ví dụ thực tế cho dễ hình dung.
Giả sử bạn đang làm một server có hàng nghìn kết nối cùng lúc. Thay vì mỗi kết nối một thread, bạn dùng Virtual Threads để xử lý cho nhẹ.
import java.util.concurrent.*;
public class VirtualThreadExample {
public static void main(String[] args) {
// try-with-resources: close() chờ mọi task chạy xong (Java 19+)
try (ExecutorService executorService = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 1000; i++) {
final int connectionId = i;
executorService.submit(() -> {
// Xử lý kết nối
System.out.println("Handling connection " + connectionId + " in Virtual Thread");
});
}
}
}
}Ở đây ứng dụng tạo 1000 Virtual Threads để xử lý các kết nối. Bản cũ của ví dụ này gọi shutdown() rồi để main kết thúc luôn. shutdown() không chờ task chạy xong, mà virtual thread lại là daemon, nên JVM thoát và phần lớn task không kịp chạy (mình chạy thử với task có sleep(10ms): 0/1000 task xong). Từ Java 19, ExecutorService là AutoCloseable, dùng try-with-resources như trên thì close() sẽ chờ hết task.
1000 thì platform thread vẫn gánh được. Lợi thế của virtual thread lộ rõ khi số tác vụ chờ I/O đồng thời lên hàng chục, hàng trăm nghìn.
# lưu ý khi dùng virtual threads
Virtual Threads giải quyết gọn bài toán chờ I/O, nhưng trước khi bật đại trà trên production, bạn cần nắm rõ năm điểm giới hạn của nó:
Thứ nhất, Virtual Threads không giúp code tính toán nặng (CPU-bound) chạy nhanh hơn. Nếu tác vụ của bạn là nén ảnh, mã hoá hay nhân ma trận liên tục không có nhịp dừng I/O nào, việc tạo một triệu virtual thread chỉ làm tốn thêm công lập lịch trên vài carrier thread, trong khi số core CPU vật lý vẫn giữ nguyên. Bài toán CPU-bound vẫn là sân của ForkJoinPool hoặc parallel stream truyền thống.
Thứ hai, chuyện đồng bộ hoá (synchronization) và race condition vẫn y hệt như cũ. Virtual thread vẫn chạy đồng thời trên nhiều nhân CPU, nên hai virtual thread cùng sửa một biến HashMap hay cộng trừ một biến đếm chung mà không có ReentrantLock hoặc cấu trúc thread-safe thì dữ liệu vẫn hỏng như thường.
Thứ ba là hiện tượng Pinning (ghim carrier thread): trên các bản từ Java 21 đến Java 23, nếu một virtual thread đi vào bên trong khối synchronized (hoặc đang gọi hàm native qua JNI) rồi gặp thao tác blocking I/O trong đó, JVM không thể gỡ (unmount) nó ra khỏi carrier thread được. Carrier thread đó bị "ghim" cứng luôn cho tới khi I/O xong; nếu cả dàn carrier thread (mặc định chỉ bằng số core CPU) cùng bị ghim thì cả ứng dụng đứng hình. Cách tránh trên Java 21–23 là thay synchronized bọc quanh I/O bằng ReentrantLock (hoặc bật cờ -Djdk.tracePinnedThreads=full để dò). Tin vui là từ Java 24 (JEP 491), cơ chế object monitor đã được viết lại để synchronized cũng unmount được bình thường.
Thứ tư, đừng cho virtual thread vào pool, mà hãy dùng Semaphore để giới hạn tài nguyên phía sau. Bản thân virtual thread cực rẻ nên mỗi tác vụ cứ tạo mới rồi bỏ, nhưng database hay API đối tác phía sau lại rất dễ sập nếu bị 100.000 virtual thread ập vào cùng lúc. Thay vì giới hạn bằng một thread pool 20 luồng như xưa, bạn cứ để 100.000 virtual thread chạy nhưng chặn trước cửa hàm gọi DB bằng một Semaphore(20): 99.980 virtual thread kia sẽ tự unmount nhẹ nhàng chờ tới lượt mà không chiếm OS thread nào.
Cuối cùng là cẩn thận với ThreadLocal: virtual thread vẫn hỗ trợ đầy đủ ThreadLocal, nhưng vì bạn có thể tạo hàng triệu virtual thread mỗi phút và không tái sử dụng chúng, việc nhét những object nặng (như SimpleDateFormat, buffer lớn) vào ThreadLocal để "cache theo thread" sẽ phản tác dụng: object bị tạo lại cho từng thread mới nên chẳng cache được gì, còn khi có hàng triệu thread sống cùng lúc thì mỗi thread giữ một bản riêng, tốn bộ nhớ đáng kể.
# lời kết
Trước khi bật, tự hỏi một câu: service của bạn phần lớn thời gian là chờ hay là tính? Mở thread dump hoặc profiler lúc tải cao. Nếu đa số thread đang chờ I/O thì Virtual Threads đáng thử; nếu CPU đã gần kín thì nó không giúp gì, xem lại lưu ý thứ nhất ở trên.
Với Spring Boot 3.2+, bật thử bằng spring.threads.virtual.enabled=true là cách nhanh nhất để thấy khác biệt. Đo throughput trước và sau với cùng một bài load test, và trên Java 21–23 thì chạy kèm -Djdk.tracePinnedThreads=full để bắt các chỗ synchronized đang ghim carrier. Đừng quên đặt Semaphore trước những tài nguyên có giới hạn như connection pool. Muốn đi sâu hơn thì đọc thêm bài Java concurrency và những cái bẫy khi đưa virtual thread lên production.
Chỉ là những ghi chép cá nhân với hy vọng mang lại chút giá trị. Nếu thấy hữu ích, đừng ngại chia sẻ cho bạn bè & đồng nghiệp nhé!
Happy coding 😎 👍🏻 🚀 🔥.