Le framework Executor gère des pools de threads pour que vous soumettiez des tâches au lieu de créer manuellement des threads, et CompletableFuture compose des opérations asynchrones de manière déclarative. Ensemble, ils constituent la façon moderne de faire du travail concurrent/asynchrone en Java — en évitant le coût et la complexité de la gestion brute des threads.
// ❌ 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
}
// ✅ 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
Un ExecutorService sépare le quoi (les tâches) du comment (la gestion des threads) — il réutilise un pool limité de threads, prévenant l'épuisement des ressources et le surcoût de la création constante de threads.
Future<Integer> f = executor.submit(task);
f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking
Future.get() bloque, et vous ne pouvez pas facilement chaîner des opérations dépendantes ou combiner des résultats — c'est ce que CompletableFuture corrige.
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 vous permet de construire des pipelines non-bloquants — transformant (thenApply), chaînant des appels asynchrones dépendants (thenCompose), et gérant les erreurs (exceptionally) — sans bloquer les threads.
// 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, et anyOf coordonnent élégamment plusieurs tâches asynchrones — exécutant du travail indépendant en parallèle et combinant les résultats.
Le framework Executor et CompletableFuture sont la façon moderne et correcte de gérer la concurrence et le travail asynchrone en Java, remplaçant la gestion manuelle des threads sujette aux erreurs.
Les pools de threads (ExecutorService) évitent l'épuisement des ressources et le surcoût de la création d'un thread par tâche — essentiel pour les serveurs évolutifs.
CompletableFuture résout la limitation de blocage de Future en activant des pipelines composables et non-bloquants qui chaînent, transforment, combinent et gèrent les erreurs des opérations asynchrones de manière déclarative — crucial pour les services I/O-bound efficaces qui doivent coordonner de nombreux appels concurrents (base de données, API, microservices).
Comprendre ces concepts (par rapport aux threads bruts et aux Futures bloquants) est fondamental pour construire des applications Java concurrentes performantes et évolutives, et c'est une compétence clé au niveau senior.