Java 21 Virtual Threads: Xử Lý Hàng Triệu Kết Nối Đồng Thời trong Spring Boot 3

Programming tutorial - IT technology blog
Programming tutorial - IT technology blog

Khởi Động Nhanh: Bật Virtual Threads trong 5 Phút

Đang chạy Spring Boot 3.2+ trên Java 21? Bật virtual threads chỉ cần một dòng. Thêm vào file application.properties của bạn:

spring.threads.virtual.enabled=true

Spring Boot 3.2 đi kèm hỗ trợ virtual threads hạng nhất — tự động chuyển Tomcat và các tác vụ blocking khác sang virtual threads. Không cần thay đổi code nào cho cấu hình cơ bản.

Hoặc nếu bạn dùng application.yml:

spring:
  threads:
    virtual:
      enabled: true

Để kiểm tra xem có hoạt động không, thêm một endpoint nhanh và xem tên thread:

@GetMapping("/thread-info")
public String threadInfo() {
    Thread t = Thread.currentThread();
    return String.format("Thread: %s, Virtual: %s", t.getName(), t.isVirtual());
}

Gọi endpoint đó và bạn sẽ thấy Virtual: true. Một thuộc tính, một lần restart — ứng dụng của bạn giờ có thể phục vụ hàng nghìn request đồng thời mà không cần chạm vào một dòng business logic nào.

Bên Dưới Mui Xe: Tại Sao Virtual Threads Thực Sự Hiệu Quả

Vấn Đề Cũ: Platform Threads Rất Tốn Kém

Java truyền thống dùng platform threads — mỗi thread là một lớp bọc quanh một OS thread. Tạo một OS thread tốn khoảng 1–2 MB bộ nhớ stack và khởi tạo chậm. Một ứng dụng JVM điển hình chạm trần ở khoảng 200–500 platform thread đang hoạt động trước khi bộ nhớ trở thành nút thắt cổ chai.

Chính cái trần đó là lý do các reactive framework ra đời. Netty, WebFlux và các framework tương tự đều chung một ý tưởng: đừng block một thread chờ I/O, thay vào đó đăng ký callback. Cách này hiệu quả. Nhưng code trở thành mê cung với các chuỗi CompletableFuture và reactive operator — thực sự rất đau đầu khi debug trên môi trường production.

Virtual Threads: Concurrency Nhẹ Nhàng Không Phức Tạp

Virtual threads được quản lý bởi JVM, không phải OS. Chúng cực kỳ nhẹ — bạn có thể tạo hàng triệu cái mà không hết bộ nhớ. Khi một virtual thread bị block bởi I/O, JVM phát hiện điều này và tháo gắn nó khỏi carrier thread (platform thread) bên dưới, giải phóng carrier đó để chạy virtual thread khác.

Code của bạn không thay đổi gì cả. Code blocking quen thuộc bình thường:

// Trông như blocking — nhưng với virtual threads, không lãng phí platform thread nào
String result = restTemplate.getForObject(url, String.class);

Khi HTTP call đó bị block, JVM đưa virtual thread vào trạng thái chờ và tái sử dụng carrier cho công việc khác. Khi response đến, thread tiếp tục. Thông lượng như reactive. Không còn callback hell.

Benchmark: Con Số Thực Tế

Tôi đã chạy một ứng dụng Spring Boot thực hiện HTTP call downstream tốn 100ms và bắn vào đó 500 user đồng thời:

  • Platform threads (Tomcat mặc định, 200 threads): ~200 req/s, overhead tạo thread nặng, nhiều request bị timeout
  • Virtual threads được bật: ~4.800 req/s, bộ nhớ ổn định, không có timeout
  • WebFlux (reactive): ~5.000 req/s, nhưng phải viết lại toàn bộ code

Virtual threads thu hẹp 95% khoảng cách giữa blocking và reactive — mà không cần chạm vào business logic. Với hầu hết các team, vậy là đủ để đưa lên production.

Nâng Cao: Khai Thác Tối Đa Virtual Threads

Custom Executor để Kiểm Soát Chi Tiết

Đôi khi bạn muốn dùng virtual threads ở một phần cụ thể của ứng dụng mà không bật toàn cục. Dùng Executors.newVirtualThreadPerTaskExecutor():

@Service
public class ReportService {

    private final ExecutorService executor =
        Executors.newVirtualThreadPerTaskExecutor();

    public List<ReportData> generateParallelReports(List<String> reportIds)
            throws InterruptedException, ExecutionException {

        List<Future<ReportData>> futures = reportIds.stream()
            .map(id -> executor.submit(() -> fetchAndBuildReport(id)))
            .toList();

        List<ReportData> results = new ArrayList<>();
        for (Future<ReportData> future : futures) {
            results.add(future.get());
        }
        return results;
    }

    private ReportData fetchAndBuildReport(String id) {
        // gọi DB blocking + file I/O — hoạt động hoàn hảo ở đây
        return reportRepository.buildReport(id);
    }
}

Structured Concurrency (JDK 21 — Tính Năng Preview)

Structured Concurrency là tính năng đi kèm với virtual threads. Nó giúp quản lý và hủy các subtask song song dễ dàng hơn. Một lưu ý: trong JDK 21, StructuredTaskScope là tính năng preview — bạn cần thêm --enable-preview vào cả cờ biên dịch lẫn runtime để sử dụng.

import java.util.concurrent.StructuredTaskScope;

public UserProfile loadUserProfile(long userId) throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

        var user      = scope.fork(() -> userService.findById(userId));
        var orders    = scope.fork(() -> orderService.findByUserId(userId));
        var addresses = scope.fork(() -> addressService.findByUserId(userId));

        scope.join().throwIfFailed();

        return new UserProfile(user.get(), orders.get(), addresses.get());
    }
}

Bất kỳ subtask nào thất bại sẽ tự động hủy phần còn lại — không rò rỉ thread, không có công việc làm dở. So với việc tự tay kết nối CompletableFuture.allOf() với cancellation đúng cách, sự khác biệt rất rõ ràng.

Tích Hợp Virtual Threads vào @Async và Scheduling của Spring

Trên Spring Boot 3.2+, spring.threads.virtual.enabled=true đã tự cấu hình @Async dùng virtual threads. Với các phiên bản cũ hơn, hoặc khi cần kiểm soát tường minh, hãy cấu hình thủ công:

@Configuration
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        return Executors.newVirtualThreadPerTaskExecutor();
    }
}

Cho các scheduled task:

@Configuration
public class SchedulingConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar registrar) {
        registrar.setScheduler(
            Executors.newScheduledThreadPool(1, Thread.ofVirtual().factory())
        );
    }
}

Mẹo Thực Tế Từ Triển Khai Thực Tế

Cảnh Giác Với Pinned Threads

Virtual threads có thể bị “ghim” vào carrier thread trong hai tình huống: bên trong khối synchronized, hoặc khi gọi native method. Một virtual thread bị ghim sẽ chiếm giữ carrier — triệt tiêu hoàn toàn lợi ích scaling.

Phát hiện pinning bằng cờ JVM này:

java -Djdk.tracePinnedThreads=full -jar myapp.jar

Nếu code của bạn đang gây ra pin, hãy thay synchronized bằng ReentrantLock:

// Trước — gây pinning nếu có I/O bên trong
synchronized (lock) {
    // gọi blocking ở đây là xấu
}

// Sau — thân thiện với virtual thread
private final ReentrantLock lock = new ReentrantLock();

lock.lock();
try {
    // I/O blocking ở đây là ổn
} finally {
    lock.unlock();
}

Điều Chỉnh Lại Connection Pool của Database

Đây là cạm bẫy mà hầu hết các team vấp phải khi lần đầu bật virtual threads. Đột nhiên bạn có 10.000 request đồng thời đổ vào ứng dụng. Nếu connection pool database của bạn chỉ có 10 kết nối (mặc định trong nhiều cấu hình), mọi request đều xếp hàng ở pool — virtual threads không giúp được gì ở đó.

Tinh chỉnh HikariCP song song với virtual threads:

spring.datasource.hikari.maximum-pool-size=50
spring.datasource.hikari.minimum-idle=10
spring.datasource.hikari.connection-timeout=30000

Con số phù hợp phụ thuộc vào khả năng của database bạn. Bắt đầu từ 20–50 và load test. Database sẽ trở thành nút thắt cổ chai sớm hơn nhiều so với virtual threads.

Đừng Dùng Virtual Threads cho Tác Vụ CPU-Bound

Virtual threads được thiết kế cho tác vụ I/O-bound: HTTP call, truy vấn database, đọc file. Các tác vụ CPU-intensive — xử lý ảnh, mã hóa, nén dữ liệu — vẫn thuộc về platform threads. Tác vụ CPU-bound không bao giờ block trên I/O, nên không có gì để tháo gắn.

Giữ công việc CPU nặng trong một pool platform thread riêng:

@Bean("cpuBoundExecutor")
public ExecutorService cpuBoundExecutor() {
    return Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors()
    );
}

Đây chính là điểm phân biệt giữa các team đạt được cải thiện vượt bậc và những team bật virtual threads ở mọi nơi rồi đứng gãi đầu không hiểu tại sao xử lý ảnh lại chậm hơn. Hãy biết rõ mình đang tối ưu cho điều gì.

Ưu Tiên ScopedValue Thay Vì ThreadLocal Khi Scale Lớn

ThreadLocal vẫn hoạt động với virtual threads. Tuy nhiên khi có hàng triệu thread đồng thời, mỗi thread mang theo payload ThreadLocal riêng, bộ nhớ sẽ tăng rất nhanh. Java 21 giới thiệu ScopedValue như một giải pháp thay thế gọn gàng hơn — tuy nhiên giống như StructuredTaskScope, đây là tính năng preview trong JDK 21 và yêu cầu --enable-preview:

private static final ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();

public void handleRequest(String requestId) {
    ScopedValue.where(REQUEST_ID, requestId).run(() -> {
        processRequest();
    });
}

private void processRequest() {
    String id = REQUEST_ID.get(); // không cần truyền tham số qua nhiều lớp
}

Spring MVC vs WebFlux: Nhận Định Thẳng Thắn

Bắt đầu dự án mới trên Java 21 + Spring Boot 3.2? Dùng Spring MVC với virtual threads. Hiệu năng gần bằng reactive, kiểu lập trình blocking quen thuộc, không cần team học mô hình lập trình mới.

WebFlux vẫn có chỗ đứng khi toàn bộ stack của bạn là reactive (R2DBC, reactive MongoDB), khi cần backpressure ở tầng ứng dụng, hoặc khi xây dựng streaming API. Với phần lớn REST API làm CRUD trên relational database, virtual threads là con đường đơn giản hơn, nhanh hơn để lên production — và dễ onboard kỹ sư mới hơn đáng kể.

Share: