Kaip Executor framework ir CompletableFuture padeda su asinchroniniu darbu?

Question

Accepted Answer

**Executor framework** valdo gijų telkinius, todėl jūs pateikiate *uždavinius* vietoj to, kad rankiniu būdu kurtumėte gijas, o **`CompletableFuture`** deklaratyviai komponuoja asinchronines operacijas. Kartu jie yra šiuolaikinis būdas atlikti lygiagretųjį/asinchroninį darbą Java — vengiama žalos ir sudėtingumo iš neapdoroto gijų valdymo. ## Problemos su neapdorotomis gijomis ```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 — valdomi gijų telkiniai ```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` atskiria *ką* (uždavinius) nuo *kaip* (gijų valdymas) — jis iš naujo naudoja ribotą gijų telkinį, todėl išvengiama išteklių išsekimo ir nuolatinio gijų kūrimo pridėtos vertės. ## Future apribojimas ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` blokuoja, ir negalite lengvai susieti priklausomų operacijų ar sujungti rezultatų — tai yra tai, ką `CompletableFuture` išsprendžia. ## CompletableFuture — komponuojamas asinchroninis ```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` leidžia kurti **ne blokuojančias konvejerio linijas** — transformuoti (`thenApply`), susieti priklausomus asinchroninius skambučius (`thenCompose`) ir tvarkyti klaidas (`exceptionally`) — neblokuojant gijų. ## Kelių asinchroninių operacijų derinimas ```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` ir `anyOf` elegantiškui suderinti kelias asinchronines užduotis — paleidžiant nepriklausomus darbus lygiagrečiai ir sujungiant rezultatus. ## Kodėl tai svarbu Executor framework ir CompletableFuture yra **šiuolaikinis, teisingas būdas** tvarkyti lygiagretumą ir asinchroninį darbą Java, pakeičiant klaidoms linkusią rankinę gijų valdymą. Gijų telkiniai (ExecutorService) išvengia išteklių išsekimo ir gijų kūrimo per užduotį pridėtos vertės — esminės skaliausiai šaliems. CompletableFuture sprendžia Future blokavimo apribojimą, įgalindama **komponuojamas, ne blokuojančias konvejerio linijas**, kurios susieja, transformuoja, derina ir klaidoms tvarko asinchronines operacijas deklaratyviai — esminės efektyviosioms I/O ribotoms paslaugoms, kurios turi suderinti daug lygiagretių skambučių (duomenų bazė, API, mikrotarnybos). Šių supratimai (virš neapdorotų gijų ir blokuojančių Future) yra pagrindinis dalykas kuriant našias, skaliausias lygiagretias Java aplikacijas ir yra pagrindinė aukštesnio lygio kompetencija.