Kako Executor framework i CompletableFuture pomažu u asinkronom radu?

Question

IT Interview Practice · Accepted Answer

**Executor framework** upravlja grupama niti tako da submituješ *zadatke* umjesto ručnog kreiranja niti, a **`CompletableFuture`** deklarativno komponira asinkrone operacije. Zajedno predstavljaju moderan način za obavljanje konkurentnog/asinkronog rada u Javi — izbjegavajući troškove i kompleksnost ručnog upravljanja nitima. ## Problem s neobrađenim nitima ```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 — upravljane grupe niti ```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` razdvaja *što* (zadaci) od *kako* (upravljanje nitima) — ponovno koristi ograničenu grupu niti, sprječavajući iscrpljivanje resursa i режиме stalnog kreiranja niti. ## Ograničenje Future-a ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` blokira, a ne možeš jednostavno povezati zavisne operacije ili kombinirati rezultate — što je problem koji `CompletableFuture` rješava. ## CompletableFuture — komponibilna asinkrona rješenja ```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` te upućuje da gradišnjene-blokiranje cjevovode** — transformirajući (`thenApply`), povezujući zavisne asinkrone pozive (`thenCompose`), i rukujući greškama (`exceptionally`) — bez blokiranje niti. ## Kombiniranje više asinkrenih operacija ```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`, i `anyOf` elegantno koordiniraju više asinkrenih zadataka — pokušavajući nezavisan rad paralelno i kombinirajući rezultate. ## Zašto je važno Executor framework i CompletableFuture su **moderan, ispravan način** za rukovanje konkurencijom i asinkronim radom u Javi, zamjenjujući podložne greškama ručno upravljanje nitima. Grupe niti (ExecutorService) izbjegavaju iscrpljivanje resursa i režijem kreiranja niti za svaki zadatak — bitno za skalabilne servere. CompletableFuture rješava ograničenje Future-a koji blokiraju omogućavanjem **komponibilnih, ne-blokiranje cjevovoda** koji povezuju, transformiraju, kombiniraju, i rukovanju greškama asinkrenim operacijama deklarativno — bitno za efikasne usluge vezane uz U/I koje moraju koordinirati mnogo konkurentnih poziva (baza podataka, API, mikroservisi). Razumijevanje ovih (umjesto neobrađenih niti i blokiranja Future-a) je temeljno za gradnju performantnih, skalabilnih konkurentnih Java aplikacija i ključna je kompetencija na višoj razini.

Problem s neobrađenim nitima

ExecutorService — upravljane grupe niti

Ograničenje Future-a

CompletableFuture — komponibilna asinkrona rješenja

Kombiniranje više asinkrenih operacija

Zašto je važno

Povezana pitanja