Jak framework Executor a CompletableFuture pomáhají s asynchronní prací?

Question

Accepted Answer

Framework **Executor** spravuje fondy vláken, takže místo ručního vytváření vláken odesíláte *úkoly*, a **`CompletableFuture`** skládá asynchronní operace deklarativně. Společně představují moderní způsob, jak provádět souběžnou/asynchronní práci v Javě — zabraňují nákladům a složitosti správy surových vláken. ## Problém se surorovými vlákny ```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 — spravované fondy vláken ```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` odděluje *co* (úkoly) od *jak* (správa vláken) — znovu používá ohraničený fond vláken, čímž brání vyčerpání prostředků a režii neustálého vytváření vláken. ## Omezení Future ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` blokuje a nemůžete snadno zřetězit závislé operace nebo kombinovat výsledky — to je to, co `CompletableFuture` řeší. ## CompletableFuture — kompozitní asynchroní ```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` vám umožňuje vytvářet **neblokující kanály** — transformovat (`thenApply`), zřetězovat závislá asynchronní volání (`thenCompose`) a zpracovávat chyby (`exceptionally`) — bez blokování vláken. ## Kombinování více asynchronních operací ```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` a `anyOf` elegantně koordinují více asynchronních úkolů — spouštějí nezávislou práci paralelně a kombinují výsledky. ## Proč to znamená Framework Executor a CompletableFuture jsou **moderní, správný způsob** řešení souběžnosti a asynchronní práce v Javě, nahrazující náchylnou k chybám ruční správu vláken. Fondy vláken (ExecutorService) zabraňují vyčerpání prostředků a režii vytváření vlákna na úkol — nezbytné pro škálovatelné servery. CompletableFuture řeší omezení Future kvůli blokování tím, že umožňuje **kompozitní, neblokující kanály**, které zřetězují, transformují, kombinují a zpracovávají chyby asynchronních operací deklarativně — zásadní pro efektivní služby vázané na vstupně-výstupní operace, které musí koordinovat mnoho souběžných volání (databáze, API, mikroslužby). Pochopení těchto konceptů (ve srovnání se suroovými vlákny a blokujícími Future) je základní dovedností pro vytváření výkonných a škálovatelných souběžných aplikací v Javě a je klíčovou kompetencí na úrovni senior.