Bagaimana Executor framework dan CompletableFuture membantu dengan async work?

Question

Accepted Answer

**Executor framework** mengelola pool thread sehingga Anda mengirimkan *task* daripada membuat thread secara manual, dan **`CompletableFuture`** mengkomposisi operasi asinkron secara deklaratif. Bersama-sama mereka adalah cara modern untuk melakukan pekerjaan concurrent/async di Java — menghindari biaya dan kompleksitas manajemen thread mentah. ## Masalah dengan thread mentah ```java // ❌ creating a thread per task is expensive and unbounded → can exhaust resources for (Task t : tasks) { new Thread(() -> process(t)).start(); // 10,000 tasks → 10,000 threads → crash } ``` ## ExecutorService — managed thread pools ```java // ✅ a fixed pool reuses a bounded set of threads for many tasks ExecutorService executor = Executors.newFixedThreadPool(10); Future future = executor.submit(() -> compute()); // submit a task Integer result = future.get(); // blocks until the result is ready executor.shutdown(); // stop accepting tasks; let running ones finish ``` `ExecutorService` memisahkan *apa* (task) dari *bagaimana* (manajemen thread) — ia menggunakan kembali pool thread yang terbatas, mencegah kehabisan resource dan overhead pembuatan thread yang konstan. ## Keterbatasan Future ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` memblokir, dan Anda tidak dapat dengan mudah merantai operasi dependen atau menggabungkan hasil — yang merupakan apa yang diperbaiki `CompletableFuture`. ## CompletableFuture — composable async ```java CompletableFuture.supplyAsync(() -> fetchUser(id)) // run async, returns a value .thenApply(user -> user.getName()) // transform the result (non-blocking) .thenApply(String::toUpperCase) .thenAccept(name -> System.out.println(name)) // consume the final result .exceptionally(ex -> { log(ex); return null; }); // handle errors in the chain ``` `CompletableFuture` memungkinkan Anda membangun **non-blocking pipelines** — mentransformasi (`thenApply`), merantai panggilan async dependen (`thenCompose`), dan menangani error (`exceptionally`) — tanpa memblokir thread. ## Menggabungkan multiple async operations ```java // run two independent async calls in PARALLEL and combine their results CompletableFuture userF = CompletableFuture.supplyAsync(() -> fetchUser(id)); CompletableFuture orderF = CompletableFuture.supplyAsync(() -> fetchOrder(id)); userF.thenCombine(orderF, (user, order) -> buildProfile(user, order)) .thenAccept(profile -> render(profile)); // wait for many to complete CompletableFuture.allOf(f1, f2, f3).join(); // all done ``` `thenCombine`, `allOf`, dan `anyOf` mengoordinasikan multiple async task dengan elegan — menjalankan pekerjaan independen secara paralel dan menggabungkan hasil. ## Mengapa ini penting Executor framework dan CompletableFuture adalah **cara modern dan benar** untuk menangani concurrency dan async work di Java, menggantikan manajemen thread manual yang rawan error. Thread pool (ExecutorService) menghindari kehabisan resource dan overhead pembuatan thread per task — essential untuk server yang scalable. CompletableFuture mengatasi keterbatasan blocking dari Future dengan mengaktifkan **composable, non-blocking pipelines** yang merantai, mentransformasi, menggabungkan, dan menangani error operasi async secara deklaratif — crucial untuk service berbasis I/O yang efisien yang harus mengoordinasikan banyak panggilan concurrent (database, API, microservice). Memahami ini (dibanding raw thread dan blocking Future) adalah fundamental untuk membangun concurrent Java application yang performan dan scalable, dan merupakan key competency senior-level.