Het Executor-framework beheert pools van threads, dus je dient taken in in plaats van handmatig threads aan te maken, en CompletableFuture stelt asynchrone bewerkingen declaratief samen. Samen zijn ze de moderne manier om gelijktijdig/asynchroon werk in Java uit te voeren — je vermijdt de kosten en complexiteit van direct thread-beheer.
(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
Een ExecutorService scheidt het wat (taken) van het hoe (thread-beheer) — het hergebruikt een beperkte pool van threads, wat uitputting van resources en overhead van constante thread-aanmaak voorkomt.
Future<Integer> f = executor.submit(task);
f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking
Future.get() blokkeert, en je kunt niet gemakkelijk afhankelijke bewerkingen aan elkaar koppelen of resultaten combineren — dat is wat CompletableFuture oplost.
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 stelt je in staat om niet-blokkerende pijplijnen op te bouwen — transformeren (thenApply), afhankelijke async-oproepen aan elkaar koppelen (thenCompose), en fouten afhandelen (exceptionally) — zonder threads te blokkeren.
// 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, en anyOf coördineren elegant meerdere async-taken — voerend onafhankelijk werk parallel uit en combineren resultaten.
Het Executor-framework en CompletableFuture zijn de moderne, juiste manier om gelijktijdigheid en asynchroon werk in Java af te handelen, vervangend foutgevoelig handmatig thread-beheer.
Thread pools (ExecutorService) voorkomen uitputting van resources en overhead van het aanmaken van een thread per taak — essentieel voor schaalbare servers.
CompletableFuture lost de blokkerende beperking van Future op door composeerbare, niet-blokkerende pijplijnen mogelijk te maken die asynce bewerkingen declaratief aan elkaar koppelen, transformeren, combineren en fouten afhandelen — cruciaal voor efficiënte I/O-limitatieve services die veel gelijktijdige oproepen moeten coördineren (database, API, microservices).
Het begrijpen hiervan (boven raw threads en blokkerende Futures) is fundamenteel voor het bouwen van performante, schaalbare gelijktijdige Java-applicaties en is een sleutelcompetentie op seniorenniveau.