Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

ConcurrencySenior21 phút đọc

ExecutorService, thread pool và virtual thread trong Java

Ôn 14 thẻ
Trong bài này

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, @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ên
Future<T> f = pool.submit(callable);    // lấy kết quả qua Future
List<Future<T>> all = pool.invokeAll(tasks, 2, TimeUnit.SECONDS); // chờ tất cả, có hạn chót

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):

  1. Số thread < core → tạo thread mới, kể cả khi thread khác đang rảnh.
  2. Đủ core → đưa vào hàng đợi.
  3. Hàng đợi đầy → tạo thêm thread tới max.
  4. Đủ 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

Nộp 7 task chậm (300 ms) vào pool trên:

task 1 -> threads=1, queued=0
task 2 -> threads=2, queued=0
task 3 -> threads=2, queued=1
task 4 -> threads=2, queued=2
task 5 -> threads=3, queued=2
task 6 -> threads=4, queued=2
task 7 -> rejected

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.
  • Bên dưới, socket được đăng ký vào một poller dùng epoll trên Linux; xem I/O model: blocking, non-blocking, epoll và file descriptor.
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.

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.

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.

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.