Framework Executor zarządza pulami wątków, dzięki czemu przesyłasz zadania zamiast ręcznie tworzyć wątki, a CompletableFuture komponuje operacje asynchroniczne w sposób deklaratywny. Razem stanowią nowoczesny sposób na pracę z równoczesnością/asynchronią w Javie — unikając kosztów i złożoności surowego zarządzania wątkami.
(Task t : tasks) {
(() -> process(t)).start();
}
// ✅ a fixed pool reuses a bounded set of threads for many tasks
ExecutorService executor = Executors.newFixedThreadPool(10);
Future<Integer> 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 oddziela co (zadania) od jak (zarządzanie wątkami) — ponownie wykorzystuje ograniczoną pulę wątków, zapobiegając wyczerpaniu zasobów i narzutowi ciągłego tworzenia wątków.
Future<Integer> f = executor.submit(task);
f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking
Future.get() blokuje, i nie możesz łatwo łączyć operacji zależnych ani kombinować wyników — co właśnie naprawia CompletableFuture.
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 pozwala budować potoki bez blokowania — transformować (thenApply), łączyć zależne asynchroniczne wywołania (thenCompose) i obsługiwać błędy (exceptionally) — bez blokowania wątków.
// run two independent async calls in PARALLEL and combine their results
CompletableFuture<User> userF = CompletableFuture.supplyAsync(() -> fetchUser(id));
CompletableFuture<Order> 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 koordynują wiele zadań asynchronicznych elegancko — uruchamiając niezależną pracę równolegle i kombinując wyniki.
Framework Executor i CompletableFuture to nowoczesny, poprawny sposób obsługi równoczęści i pracy asynchronicznej w Javie, zastępując podatne na błędy ręczne zarządzanie wątkami.
Pule wątków (ExecutorService) unikają wyczerpania zasobów i narzutu tworzenia wątku na zadanie — niezbędne dla skalowalnych serwerów.
CompletableFuture rozwiązuje ograniczenie blokowania Future poprzez umożliwienie komponowalnych, nieblokujących potoków, które łańcuchują, transformują, kombinują i obsługują błędy operacji asynchronicznych deklaratywnie — kluczowe dla wydajnych usług I/O-bound, które muszą koordynować wiele jednoczesnych wywołań (baza danych, API, mikrousługi).
Rozumienie tych koncepcji (w porównaniu z surowymi wątkami i blokowaniem Futures) jest fundamentalne dla budowania wydajnych, skalowalnych aplikacji równoczęnych w Javie i jest kluczową kompetencją poziomu senior.