Lỗi bỏ qua các bước sau, đi tới chỗ xử lý lỗi đầu tiên, gói trong CompletionException. orTimeout chỉ đổi trạng thái CF, task bên dưới vẫn chạy.
flowchart TD
A["Bước lỗi"] --> B["Bỏ qua các thenX"]
B --> C["exceptionally / handle"]
C --> D["Unwrap getCause rồi xét loại"]
T["orTimeout, cancel"] -.->|thread vẫn bận| E["Timeout thật ở HTTP, JDBC client"]
5Context và virtual thread
MDC, SecurityContext nằm trong ThreadLocal, không tự sang thread khác: bọc executor bằng TaskDecorator. Trên Java 21, virtual thread với code blocking thường dễ đọc hơn mà nhanh ngang.
@Async gọi trong cùng class: chạy đồng bộ
@Async trả CompletableFuture<T> để người gọi xử lý lỗi
Virtual thread + blocking: 508 ms, CF: 506 ms
Structured concurrency: một task lỗi thì huỷ thật các task khác
API dashboard gọi ba service: gọi lần lượt thì người dùng chờ tổng, gọi song song thì chỉ chờ cái chậm nhất. Bài này chỉ cách làm việc đó bằng CompletableFuture cho đúng (executor, lỗi, timeout, trace id), và khi nào nên viết code blocking trên virtual thread thay vì chuỗi callback. Nên đọc trước ExecutorService và virtual thread; mọi số đo trong bài là từ JDK 21 trên máy 10 core của mình.
Sơ đồ tóm tắt:
flowchart LR
R[Request] --> E["Executor riêng hoặc virtual thread"]
E --> A[supplyAsync A]
E --> B[supplyAsync B]
E --> C[supplyAsync C]
A --> J["allOf / thenCombine"]
B --> J
C --> J
J --> T["orTimeout + exceptionally"]
T --> O["Kết quả hoặc fallback"]
X["Bẫy: commonPool, mất MDC, cancel không dừng task"] -.-> E
1. Future và CompletableFuture
Ý chính:Future là “kết quả sẽ có”, nhưng chỉ lấy được bằng cách chặn ở get(). CompletableFuture thêm hai thứ: tự hoàn thành được (complete), và đăng ký việc làm tiếp khi có kết quả (thenApply, exceptionally…).
Future (Java 5)
CompletableFuture (Java 8+)
Lấy kết quả
get() chặn, có bản có timeout
join()/get() chặn, hoặc callback không chặn
Nối bước
không có
thenApply, thenCompose, thenAccept…
Gộp nhiều
tự vòng lặp get()
thenCombine, allOf, anyOf
Lỗi
ExecutionException khi get()
exceptionally, handle, whenComplete
Timeout
chỉ ở get(timeout)
orTimeout, completeOnTimeout (Java 9)
cancel(true)
interrupt thread đang chạy
không interrupt, chỉ đánh dấu huỷ
CF cài đặt cả Future và CompletionStage (“một bước trong chuỗi”). HttpClient.sendAsync của JDK, @Async của Spring và KafkaTemplate.send (Spring Kafka 3) đều trả CF. Future thuần và Callable có ở phần 1 của cụm thread.
Các phương thức hay dùng, nhóm theo việc
Bắt đầu:supplyAsync(supplier, executor) (có kết quả), runAsync(runnable, executor) (không kết quả), completedFuture(v), failedFuture(ex) (Java 9).
Mỗi thenX có ba dạng: thenX(fn), thenXAsync(fn), thenXAsync(fn, executor) (phần 2).
2. Chạy trên executor nào
Ý chính: luôn truyền executor cho supplyAsync/runAsync và các bản ...Async. Không truyền thì việc chạy trên common ForkJoinPool, pool chung của cả JVM, chỉ có số core − 1 thread và được thiết kế cho việc tính toán, không cho chờ I/O.
Parallel stream và nhiều thư viện cũng dùng pool này, nên một lời gọi chặn làm mọi thứ xếp hàng.
Đo trên máy 10 core (commonPool parallelism = 9), 50 lệnh “gọi I/O” mỗi lệnh sleep(100):
Executor
Thời gian (2 lần chạy)
Vì sao
common ForkJoinPool (9 thread)
620 ms, 622 ms
50 / 9 ≈ 6 lượt × 100 ms
newFixedThreadPool(16)
411 ms, 409 ms
50 / 16 ≈ 4 lượt
virtual thread mỗi task
103 ms, 105 ms
50 lệnh chờ cùng lúc
Callback chạy trên thread nào, và vì sao đó là vấn đề
thenApply(fn) (không Async) chạy trên thread vừa hoàn thành bước trước, hoặc ngay trên thread gọi nếu CF đã xong rồi. thenApplyAsync(fn) không truyền executor thì về common pool: trong thí nghiệm, bước này chạy trên ForkJoinPool.commonPool-worker-1 dù bước trước chạy trên executor riêng.
Với HTTP client bất đồng bộ (JDK HttpClient, Netty), thread hoàn thành CF là thread I/O của client. Làm việc nặng trong thenApply ở đó là chặn event loop của client.
Callback không Async có thể chạy trên thread của request gọi nếu CF đã xong, nên thời gian chạy và ThreadLocal phụ thuộc vào thời điểm, khó tái hiện.
Quy tắc thực dụng: bước nhẹ (map DTO) dùng thenApply; bước nặng hoặc blocking dùng thenApplyAsync(fn, executor) với executor tường minh.
Common pool có parallelism = số core − 1. Nếu số này < 2 (container 1 CPU), CF dùng một thread mới cho mỗi task thay vì pool: không còn nghẽn nhưng mất giới hạn. Đặt bằng -Djava.util.concurrent.ForkJoinPool.common.parallelism=N chỉ là vá tạm, không thay được executor riêng.
3. Ghép các bước: thenApply, thenCompose, thenCombine, allOf, anyOf
Ý chính: chọn theo hình dạng phụ thuộc. Một bước đổi giá trị: thenApply. Bước sau cần gọi bất đồng bộ dựa trên kết quả bước trước: thenCompose. Nhiều nhánh độc lập: thenCombine (hai nhánh) hoặc allOf (nhiều nhánh). Lấy nhánh nhanh nhất: anyOf.
Dùng thenApply với hàm trả về CF sẽ ra CompletableFuture<CompletableFuture<T>>, giống map thay vì flatMap trong Stream. allOf trả CF<Void>, nên lấy kết quả bằng join() từng CF trong callback: lúc đó chúng đã xong, join() không chặn.
4. Xử lý exception
Ý chính: lỗi trong một bước bỏ qua các bước thenX phía sau và đi thẳng tới chỗ xử lý lỗi đầu tiên. Trên đường đi, nó được gói trong CompletionException, nên code bắt lỗi phải unwrap getCause() trước khi xét loại.
Phương thức
Nhận gì
Trả gì
Dùng khi
exceptionally(ex -> v)
chỉ khi lỗi
giá trị thay thế
fallback
handle((v, ex) -> r)
cả hai trường hợp
giá trị mới
đổi cả kết quả lẫn lỗi thành một kiểu
whenComplete((v, ex) -> {})
cả hai
giữ nguyên kết quả/lỗi
log, metric, dọn dẹp
Kết quả đo trên JDK 21:
A1 join -> CompletionException / cause IllegalStateExceptionA2 get -> ExecutionException / cause IllegalStateExceptionB1 supplyAsync ném lỗi, exceptionally thấy : CompletionExceptionB2 completeExceptionally(X), exceptionally thấy : IllegalStateExceptionB3 completeExceptionally(X) rồi thenApply, thấy : CompletionExceptionC1 handle -> fallbackC2 whenComplete vẫn ném tiếp: orders down
Bài học từ B1–B3 (nền tảng ở exception trong Java): có gói hay không phụ thuộc vào lỗi sinh ra ở đâu. Đừng viết if (ex instanceof TimeoutException); viết helper unwrap lột hết CompletionException/ExecutionException rồi mới so.
static Throwable unwrap(Throwable t) { while ((t instanceof CompletionException || t instanceof ExecutionException) && t.getCause() != null) t = t.getCause(); return t;}
5. Timeout và giới hạn của cancel
Ý chính:orTimeout(d) hoàn thành CF bằng TimeoutException sau d; completeOnTimeout(v, d) hoàn thành bằng giá trị mặc định. Cả hai, và cả cancel(true), chỉ đổi trạng thái của CF. Task bên dưới vẫn chạy và vẫn giữ thread.
D1 orTimeout -> TimeoutException sau 306 msD2 completeOnTimeout -> cached sau 305 msE1 cancel(true) = true, isCancelled = trueE2 task vẫn chạy xong? finished=true, interrupted=falseE3 Future từ executor.submit(): interrupted=true
Javadoc của CompletableFuture.cancel ghi rõ tham số mayInterruptIfRunning “không có tác dụng”, vì CF không điều khiển việc chạy bằng interrupt. Future từ executor.submit() (một FutureTask) thì có interrupt (E3).
Timeout trên CF là timeout cho người chờ, không cho tài nguyên: 16 lời gọi treo trên pool 16 thread thì CF đã timeout nhưng thread vẫn bận.
Muốn dừng thật: cờ huỷ trong task, Future từ submit(), hoặc structured concurrency.
6. Fan-out gọi nhiều service và gộp kết quả
Ý chính: chạy các lời gọi độc lập song song thì thời gian ≈ lời gọi chậm nhất thay vì tổng. Thiết kế thật cần thêm ba thứ: executor có giới hạn, timeout cho từng nhánh, và quyết định nhánh nào bắt buộc, nhánh nào được phép thiếu (degrade).
Đo với ba “service” giả 300 ms, 500 ms, 200 ms:
Cách
Thời gian
Gọi lần lượt
1013 ms, 1014 ms
CF supplyAsync + allOf trên pool 16 thread
506 ms, 506 ms
Virtual thread + Future.get() (code blocking)
512 ms, 508 ms
var pf = CompletableFuture.supplyAsync(FanOut::profile, io);var of = CompletableFuture.supplyAsync(FanOut::orders, io);var ptf = CompletableFuture.supplyAsync(FanOut::points, io);Dashboard d = CompletableFuture.allOf(pf, of, ptf) .thenApply(v -> new Dashboard(pf.join(), of.join(), ptf.join())) .join();
sequenceDiagram
participant API as Dashboard API
participant P as profile (300 ms)
participant O as orders (500 ms)
participant S as points (200 ms)
API->>P: supplyAsync
API->>O: supplyAsync
API->>S: supplyAsync
S-->>API: 200 ms
P-->>API: 300 ms
O-->>API: 500 ms
Note over API: allOf xong ở ~506 ms, gộp kết quả
Ba quyết định thiết kế:
Nhánh bắt buộc và tuỳ chọn. Thiếu profile thì trả lỗi; thiếu điểm thưởng thì trả 0 kèm cờ degraded.
Ngân sách thời gian. Timeout tổng của API lớn hơn timeout từng nhánh, nhỏ hơn timeout của người gọi.
Sức chứa phía sau. 200 req/s × 3 nhánh = 600 lời gọi/s. Cần bulkhead (giới hạn riêng mỗi downstream) để một service chậm không ăn hết thread của các nhánh khác, và pool connection của HTTP client đủ lớn (pool của HTTP client).
7. Context propagation và @Async của Spring
Ý chính: MDC (trace id trong log), SecurityContext (user hiện tại) và transaction đều nằm trong ThreadLocal của thread request. Thread của executor không có chúng, nên code async phải mang theo bằng cách bọc executor. @Async thêm một bẫy riêng: nó là proxy, chỉ có tác dụng khi gọi từ bên ngoài bean.
Đo: đặt MDC = "trace-abc" ở thread gọi, rồi runAsync:
F1 không bọc : traceId=nullF2 có bọc : traceId=trace-abcF3 thenApplyAsync không truyền executor -> ForkJoinPool.commonPool-worker-1 traceId=null
F3: chỉ một bước ...Async quên truyền executor là context rơi mất. Cách bọc:
Executor ctxExec = task -> { Map<String, String> mdc = MDC.getCopyOfContextMap(); // chụp ở thread gọi io.execute(() -> { Map<String, String> old = MDC.getCopyOfContextMap(); if (mdc != null) MDC.setContextMap(mdc); else MDC.clear(); try { task.run(); } finally { // luôn trả lại như cũ if (old != null) MDC.setContextMap(old); else MDC.clear(); } });};
Trong Spring, logic này là một TaskDecorator gắn vào ThreadPoolTaskExecutor. SecurityContext có sẵn DelegatingSecurityContextAsyncTaskExecutor; trace của OpenTelemetry có Context.taskWrapping(executor) (mục “Context bị mất ở đâu” trong distributed tracing); Micrometer Context Propagation gom nhiều loại vào một ContextSnapshot.
Bẫy của @Async (cần @EnableAsync):
Gọi trong cùng class (this.sendMail()) đi thẳng vào object, không qua proxy, nên chạy đồng bộ mà không báo gì; cùng bẫy với @Transactional (proxy trong Spring).
Method phải chặn được bởi proxy: không private, không final, gọi trên bean do Spring quản lý (không phải object tự new).
Trả void thì lỗi chỉ vào AsyncUncaughtExceptionHandler (mặc định log); trả CompletableFuture<T> để người gọi xử lý.
Transaction của người gọi không đi theo; @Transactional trên method async là transaction mới, không thấy dữ liệu chưa commit của người gọi.
Executor mặc định của @Async
Spring Boot tự tạo applicationTaskExecutor (ThreadPoolTaskExecutor, mặc định 8 thread core, hàng đợi không giới hạn, chỉnh bằng spring.task.execution.*). Đặt queue-capacity để quá tải hiện ra thành reject thay vì phình bộ nhớ.
Bật spring.threads.virtual.enabled=true (Boot 3.2+) thì dùng virtual thread.
Không có Spring Boot và không khai báo executor: Spring dùng SimpleAsyncTaskExecutor, tạo thread mới cho mỗi lần gọi, không giới hạn.
8. Virtual thread, code blocking và structured concurrency
Ý chính: CF ra đời khi thread đắt nên phải “không chặn”. Trên Java 21 thread ảo rẻ, nên với code nghiệp vụ gọi I/O, cách đơn giản thường là mỗi nhánh một virtual thread, code blocking và try/catch bình thường: nhanh ngang CF (508 so với 506 ms) mà đọc như code tuần tự.
try (var vt = Executors.newVirtualThreadPerTaskExecutor()) { Future<Profile> p = vt.submit(() -> profileClient.get(id)); // blocking, có read timeout Future<Orders> o = vt.submit(() -> orderClient.of(id)); return new Dashboard(p.get(), o.get()); // stack trace rõ ràng}
Structured concurrency (preview, JEP 453 ở JDK 21) gom các task con vào một scope: scope chỉ đóng khi mọi task con xong, và một task lỗi thì các task còn lại bị huỷ thật (interrupt). Đo với ShutdownOnFailure, nhánh points lỗi ở 100 ms:
ok profile,orders,points sau 504 ms profile bị huỷ (interrupted) orders bị huỷ (interrupted)lỗi: points down sau 102 ms
Đây là fail-fast và huỷ thật mà allOf thiếu.
Code StructuredTaskScope trên JDK 21 và tình trạng API
// java --enable-preview --source 21 Scope.javatry (var scope = new StructuredTaskScope.ShutdownOnFailure()) { var p = scope.fork(() -> call("profile", 300, false)); var o = scope.fork(() -> call("orders", 500, false)); var pt = scope.fork(() -> call("points", 100, true)); // ném lỗi scope.join().throwIfFailed(); // ExecutionException, các nhánh khác bị interrupt return new Dashboard(p.get(), o.get(), pt.get());}
API vẫn là preview và đã đổi hình dạng ở JDK 25 (JEP 505: StructuredTaskScope.open() với Joiner, bỏ các lớp con ShutdownOnFailure/ShutdownOnSuccess). Không nên dùng trong code production cần ổn định qua nhiều bản JDK.
Đi kèm là ScopedValue (preview ở JDK 21, chính thức ở JDK 25, JEP 506): giá trị bất biến gắn với một scope, được task con thừa hưởng; đây là hướng thay ThreadLocal cho context như user hay trace id.
Bài tập
Bài 1: Dashboard có timeout và degrade
Đề: API dashboard gọi profile (bắt buộc), orders và points (tuỳ chọn). Mỗi nhánh tối đa 800 ms. Nhánh tuỳ chọn lỗi hoặc quá hạn thì trả giá trị rỗng và ghi tên nhánh vào danh sách degraded. Giả lập: profile 300 ms, orders treo 2 s, points ném lỗi 503.
Bài 2: allOf dừng sớm
Đề: viết allOrFail(List<CF<T>>): thành công thì trả List<T>, có một nhánh lỗi thì báo lỗi ngay và huỷ các nhánh còn lại.
Lời giải Bài 1 và Bài 2 (đã chạy trên JDK 21)
static Dashboard load(Executor io) { List<String> degraded = Collections.synchronizedList(new ArrayList<>()); var p = CompletableFuture.supplyAsync(Exercise::profile, io) .orTimeout(800, TimeUnit.MILLISECONDS); // bắt buộc: lỗi thì cả request lỗi var o = CompletableFuture.supplyAsync(Exercise::orders, io) .orTimeout(800, TimeUnit.MILLISECONDS) .exceptionally(ex -> { degraded.add("orders:" + unwrap(ex).getClass().getSimpleName()); return List.of(); }); var pt = CompletableFuture.supplyAsync(Exercise::points, io) .exceptionally(ex -> { degraded.add("points:" + unwrap(ex).getMessage()); return 0; }); return CompletableFuture.allOf(p, o, pt) .thenApply(v -> new Dashboard(p.join(), o.join(), pt.join(), List.copyOf(degraded))) .join();}static <T> CompletableFuture<List<T>> allOrFail(List<CompletableFuture<T>> cfs) { var result = new CompletableFuture<List<T>>(); var failed = new AtomicBoolean(); for (var cf : cfs) cf.whenComplete((v, ex) -> { if (ex == null || !failed.compareAndSet(false, true)) return; // chỉ lỗi đầu tiên Throwable cause = unwrap(ex); cfs.forEach(c -> c.cancel(true)); // huỷ phần còn lại trước result.completeExceptionally(cause); // rồi mới báo cho người gọi }); CompletableFuture.allOf(cfs.toArray(CompletableFuture[]::new)) .thenRun(() -> result.complete(cfs.stream().map(CompletableFuture::join).toList())); return result;}
Kết quả (chạy trên virtual thread executor):
Bài 1: Dashboard[profile=vinh, orders=[], points=0, degraded=[points:points 503, orders:TimeoutException]] sau 817 msBài 2: fail sau 106 ms: boom, slow.isCancelled=true
Ghi chú:
Bài 1 mất ~810 ms vì chờ timeout của orders. Thread của orders vẫn treo tới 2 s sau đó (phần 5), nên ở code thật timeout 800 ms phải nằm ở read timeout của HTTP client.
Bài 2, lần viết đầu mình huỷ trong callback mà không có cờ failed: cancel kích hoạt lại chính callback đó với CancellationException, và người gọi nhận CancellationException thay vì lỗi gốc. Cờ compareAndSet sửa cả hai: chỉ lỗi đầu tiên được xử lý, và huỷ xảy ra trước khi người gọi được đánh thức.
slow.isCancelled=true nhưng task slow vẫn ngủ đủ 1 s: lại là giới hạn của cancel trên CF. Muốn interrupt thật, dùng structured concurrency.
Ghi nhớ
Giải thích được vì sao supplyAsync không truyền executor là nguy hiểm với I/O, và con số 620 ms so với 103 ms đến từ đâu.
Chọn đúng thenApply/thenCompose/thenCombine/allOf/anyOf theo hình dạng phụ thuộc.
Biết khi nào lỗi bị gói trong CompletionException, và vì sao phải unwrap.
Giải thích được vì sao orTimeout và cancel(true) không giải phóng thread, và timeout thật nằm ở đâu.
Mang được MDC/SecurityContext sang executor, và nhận ra @Async bị gọi nội bộ.
Câu hỏi phỏng vấn
Junior
Future và CompletableFuture khác nhau thế nào?
Future chỉ lấy kết quả bằng cách chặn ở get(); CompletableFuture cho nối bước tiếp, gộp nhiều kết quả, xử lý lỗi và timeout mà không chặn thread.
CF còn tự hoàn thành được (complete, completeExceptionally) và cài đặt CompletionStage. Khác biệt hay bị bỏ qua: cancel(true) của Future từ executor interrupt thread, của CF thì không.
Mid
thenApply và thenCompose khác nhau thế nào?
thenApply đổi giá trị (map); thenCompose dùng khi hàm của bạn trả về một CF khác, nó “làm phẳng” để ra CF<T> thay vì CF<CF<T>> (flatMap).
Ví dụ: lấy user rồi gọi bất đồng bộ lấy đơn hàng của user đó là thenCompose. Hai lời gọi độc lập chạy song song rồi ghép là thenCombine.
supplyAsync không truyền executor thì chạy ở đâu, và sao lại là vấn đề?
Chạy trên common ForkJoinPool, pool dùng chung cả JVM với số core − 1 thread, dành cho việc tính toán. Đặt I/O blocking ở đó làm nghẽn mọi CF và parallel stream khác.
Mình đo 50 lệnh chờ 100 ms: common pool 620 ms, pool 16 thread 410 ms, virtual thread 103 ms. Luôn truyền executor có giới hạn và tên thread rõ, kể cả cho các bản ...Async.
join() và get() khác nhau thế nào khi task lỗi? exceptionally nhận được exception nào?
join() ném CompletionException (unchecked), get() ném ExecutionException (checked); cả hai bọc lỗi gốc trong getCause(). exceptionally thường nhận CompletionException, trừ khi CF đó bị completeExceptionally trực tiếp.
Vì vậy code xét loại lỗi phải unwrap trước. handle nhận cả kết quả và lỗi; whenComplete chỉ quan sát, lỗi vẫn đi tiếp.
thenApply và thenApplyAsync chạy callback trên thread nào?
thenApply chạy trên thread hoàn thành bước trước; nếu bước trước đã xong lúc bạn gắn callback thì chạy ngay trên thread đang gọi thenApply. thenApplyAsync luôn đẩy callback sang executor (truyền vào, hoặc common pool).
Vì thế callback của thenApply có thể chạy trên thread I/O của HTTP client, trên thread của pool supplyAsync, hoặc trên thread request: không đoán trước được.
Callback nặng hoặc chặn (gọi DB, gọi API) đặt sau thenApply sẽ chiếm thread của người khác, ví dụ event loop của client non-blocking. Dùng thenApplyAsync(fn, executor) cho bước nặng.
thenApplyAsync(fn) không truyền executor là chạy trên ForkJoinPool.commonPool(), cùng bẫy ở mục 2 và mất context ở mục 7.
Callback nhẹ (map DTO) dùng thenApply là đủ, tránh tốn một lần chuyển thread.
Method @Async trả void ném exception thì đi đâu? Transaction của người gọi có đi theo không?
Exception không về tới người gọi: Spring đưa nó cho AsyncUncaughtExceptionHandler (mặc định SimpleAsyncUncaughtExceptionHandler chỉ log ERROR). Transaction của người gọi không đi theo, vì transaction gắn với ThreadLocal của thread gọi.
Muốn người gọi biết lỗi: trả CompletableFuture<T>; exception nằm trong future (join() ném CompletionException).
Muốn xử lý lỗi void có chủ đích (metric, cảnh báo, ghi bảng retry): cài AsyncConfigurer.getAsyncUncaughtExceptionHandler().
@Async + @Transactional trên cùng method: transaction mới mở trong thread async. Nó không thấy dữ liệu người gọi chưa commit; nếu cần dữ liệu đó, gọi async sau commit (@TransactionalEventListener(phase = AFTER_COMMIT)).
Không dùng @Async để “né” transaction dài; job cần chắc chắn chạy (gửi email đơn hàng) nên đi qua outbox hoặc queue, vì app chết là task trong pool mất.
Senior
API của bạn gọi song song ba service, một cái thỉnh thoảng treo. Bạn thiết kế thế nào?
Executor có giới hạn (hoặc virtual thread + semaphore theo downstream), timeout ở tầng HTTP client cho từng nhánh, phân nhánh bắt buộc và nhánh được degrade, và tổng ngân sách thời gian nhỏ hơn timeout của người gọi.
orTimeout chỉ giải phóng người chờ; thread vẫn treo nếu client không có read timeout.
Nhánh tuỳ chọn: exceptionally trả giá trị mặc định, đánh dấu degraded, đếm metric.
Bulkhead để service treo không ăn hết thread của các nhánh khác; circuit breaker nếu nó treo kéo dài.
Theo dõi p99 từng nhánh, vì p99 của API bằng nhánh tệ nhất.
Log của code async mất trace id và user. Vì sao và sửa thế nào?
MDC và SecurityContext nằm trong ThreadLocal của thread request; thread của executor không có chúng. Sửa bằng cách chụp context ở thread gọi và đặt lại (rồi dọn) trong task, thường qua TaskDecorator hoặc executor bọc sẵn.
Spring Security: DelegatingSecurityContextAsyncTaskExecutor. OpenTelemetry: Context.taskWrapping(executor). Micrometer Context Propagation cho nhiều loại một lúc.
Bẫy còn lại: một bước ...Async quên truyền executor sẽ về common pool và mất context. Dọn trong finally để không rò sang task sau.
Method có @Async nhưng vẫn chạy đồng bộ. Những nguyên nhân nào?
Thường nhất là gọi từ chính class đó (this.method()) nên không qua proxy; ngoài ra là thiếu @EnableAsync, method private/final, hoặc gọi trên object tự new chứ không phải bean.
Kiểm tra bằng tên thread trong log. Thêm các bẫy khác: void làm lỗi chỉ được log, transaction của người gọi không đi theo, executor mặc định của Boot có hàng đợi không giới hạn nên cần đặt queue-capacity.
Đã có virtual thread ở Java 21, còn cần CompletableFuture không?
Với code nghiệp vụ gọi I/O thì thường không: virtual thread + code blocking nhanh ngang (mình đo 508 ms so với 506 ms) mà dễ đọc và debug hơn. CF vẫn hợp khi thư viện đã trả CF, khi cần ghép/timeout theo từng bước, hoặc khi còn ở Java 17.
Cả hai cách đều cần giới hạn đồng thời theo downstream và timeout ở client. Fail-fast và huỷ thật là chỗ structured concurrency làm tốt hơn cả hai, nhưng ở JDK 21–25 nó vẫn là preview.
Từ vựng tiếng Anh
Term
Phát âm
Nghĩa
Ví dụ câu trong phỏng vấn
fan-out
/ˈfæn aʊt/
toả ra gọi nhiều nơi cùng lúc
“The dashboard fans out to three services and merges the results.”
common pool
/ˈkɑːmən puːl/
pool dùng chung của JVM
“Blocking I/O on the common pool starves parallel streams too.”
unwrap
/ʌnˈræp/
bóc lớp bọc
“We unwrap the CompletionException before checking the cause.”
fallback
/ˈfɔːlbæk/
giá trị/đường dự phòng
“The points service is optional, so it has a fallback of zero.”
degrade gracefully
/dɪˈɡreɪd ˈɡreɪsfəli/
xuống cấp có kiểm soát
“If recommendations time out, the page degrades gracefully.”
context propagation
/ˈkɑːntekst ˌprɑːpəˈɡeɪʃən/
mang ngữ cảnh sang thread khác
“Context propagation is why our async logs still carry the trace id.”
self-invocation
/self ˌɪnvəˈkeɪʃən/
tự gọi trong cùng class
“Self-invocation bypasses the proxy, so @Async does nothing.”
structured concurrency
/ˈstrʌktʃərd kənˈkɝːənsi/
đồng thời có cấu trúc
“Structured concurrency cancels sibling tasks when one fails.”
Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.