Executor framework và CompletableFuture giúp xử lý công việc bất đồng bộ như thế nào?

Question

Accepted Answer

**Executor framework** quản lý các pool thread để bạn submit *task* thay vì tạo thread thủ công, và **`CompletableFuture`** kết hợp các thao tác bất đồng bộ theo kiểu declarative. Cùng nhau, chúng là cách hiện đại để làm việc concurrent/async trong Java — tránh chi phí và sự phức tạp của việc quản lý thread thô. ## Vấn đề với thread thô ```java // ❌ tạo một thread cho mỗi task vừa đắt vừa không giới hạn → có thể cạn kiệt tài nguyên for (Task t : tasks) { new Thread(() -> process(t)).start(); // 10.000 task → 10.000 thread → crash } ``` ## ExecutorService — pool thread được quản lý ```java // ✅ một fixed pool tái sử dụng một tập thread có giới hạn cho nhiều task ExecutorService executor = Executors.newFixedThreadPool(10); Future future = executor.submit(() -> compute()); // submit một task Integer result = future.get(); // block cho tới khi có kết quả executor.shutdown(); // ngừng nhận task; để các task đang chạy hoàn thành ``` Một `ExecutorService` tách biệt *cái gì* (task) khỏi *như thế nào* (quản lý thread) — nó tái sử dụng một pool thread có giới hạn, ngăn cạn kiệt tài nguyên và chi phí của việc liên tục tạo thread. ## Hạn chế của Future ```java Future f = executor.submit(task); f.get(); // ❌ BLOCK thread gọi; không thể chain/combine mà không block ``` `Future.get()` block, và bạn không dễ dàng chain các thao tác phụ thuộc hay kết hợp kết quả — đó chính là điều `CompletableFuture` khắc phục. ## CompletableFuture — async có thể kết hợp ```java CompletableFuture.supplyAsync(() -> fetchUser(id)) // chạy async, trả về một giá trị .thenApply(user -> user.getName()) // biến đổi kết quả (non-blocking) .thenApply(String::toUpperCase) .thenAccept(name -> System.out.println(name)) // tiêu thụ kết quả cuối .exceptionally(ex -> { log(ex); return null; }); // xử lý lỗi trong chain ``` `CompletableFuture` cho phép bạn xây dựng các **pipeline non-blocking** — biến đổi (`thenApply`), chain các lời gọi async phụ thuộc (`thenCompose`), và xử lý lỗi (`exceptionally`) — mà không block thread. ## Kết hợp nhiều thao tác async ```java // chạy hai lời gọi async độc lập SONG SONG và kết hợp kết quả của chúng CompletableFuture userF = CompletableFuture.supplyAsync(() -> fetchUser(id)); CompletableFuture orderF = CompletableFuture.supplyAsync(() -> fetchOrder(id)); userF.thenCombine(orderF, (user, order) -> buildProfile(user, order)) .thenAccept(profile -> render(profile)); // chờ nhiều task hoàn thành CompletableFuture.allOf(f1, f2, f3).join(); // tất cả xong ``` `thenCombine`, `allOf`, và `anyOf` điều phối nhiều task async một cách tinh tế — chạy công việc độc lập song song và kết hợp kết quả. ## Tại sao điều này quan trọng Executor framework và CompletableFuture là **cách hiện đại, đúng đắn** để xử lý concurrency và công việc bất đồng bộ trong Java, thay thế cho việc quản lý thread thủ công dễ lỗi. Thread pool (ExecutorService) tránh được sự cạn kiệt tài nguyên và chi phí của việc tạo một thread cho mỗi task — thiết yếu cho các server có khả năng mở rộng. CompletableFuture giải quyết hạn chế blocking của Future bằng cách cho phép các **pipeline có thể kết hợp, non-blocking** chain, biến đổi, kết hợp và xử lý lỗi các thao tác async theo kiểu declarative — quan trọng cho các service I/O-bound hiệu quả phải điều phối nhiều lời gọi đồng thời (database, API, microservice). Hiểu được chúng (thay vì thread thô và blocking Future) là nền tảng để xây dựng các ứng dụng Java concurrent hiệu năng cao, có khả năng mở rộng, và là một năng lực then chốt ở trình độ senior.