Kepiye Executor framework lan CompletableFuture nulungi karo async work?

Question

Accepted Answer

**Executor framework** ngatur kolam-kolam threads supaya sampeyan nyumitake *tasks* bukuné nggawe threads kanthi manual, lan **`CompletableFuture`** nguripake operasi asynchronous kanthi deklaratif. Bebarengan-barengan iku cara modern nindakake concurrent/async work ing Java — ngindhari biaya lan kerumitan manajemen raw threads. ## Masalah karo raw threads ```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 ``` Sak `ExecutorService` misahake *apa* (tasks) saka *carane* (manajemen threads) — iku ngisi manèh kolam threads sing winates, cegah resource exhaustion lan overhead tina creation threads sing padha-padha. ## Watesan-watesane Future ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` blok, lan sampeyan ora bisa gampang-gampang serangkaian operasi sing gumantung utawa gabung asil — iku apa sing `CompletableFuture` beneri. ## 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` mungkinake sampeyan bangunan **non-blocking pipelines** — transform (`thenApply`), serangkaian panggilan async sing gumantung (`thenCompose`), lan nangani errors (`exceptionally`) — tanpa blok threads. ## Nggabung pirang-pirang operasi async ```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`, lan `anyOf` koordinasi pirang-pirang tasks async kanthi elegan — nglakokake work sing berdiri dhewe kanthi paralel lan nggabung asil. ## Menapa iki penting Executor framework lan CompletableFuture punika **cara modern, bener** kangge nangani concurrency lan asynchronous work ing Java, ngganti manajemen raw threads sing gampang kesalahan. Thread pools (ExecutorService) cegah resource exhaustion lan overhead saka nggawe thread saben task — penting kangge servers sing scalable. CompletableFuture ngatasi wates blocking Future kanthi ngidupake **composable, non-blocking pipelines** sing serangkaian, transform, gabung, lan error-handle operasi async kanthi deklaratif — penting kangge layanan I/O-bound sing kudu koordinasi pirang-pirang panggilan concurrent (database, API, microservices). Paham barang-barang iki (tinimbang raw threads lan Futures blocking) punika fundamental kangge bangunan aplikasi Java concurrent sing performan, scalable lan punika senior-level competency penting.