Das Executor-Framework verwaltet Thread-Pools, sodass Sie Tasks einreichen, anstatt Threads manuell zu erstellen, und CompletableFuture komponiert asynchrone Operationen deklarativ. Zusammen sind sie die moderne Art, nebenläufige/asynchrone Arbeiten in Java zu erledigen — die Kosten und Komplexität der rohen Thread-Verwaltung vermeidend.
(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
Ein ExecutorService trennt das Was (Tasks) vom Wie (Thread-Verwaltung) — es nutzt einen begrenzten Pool von Threads wieder, was Ressourcenerschöpfung und den Overhead von konstanter Thread-Erstellung verhindert.
Future<Integer> f = executor.submit(task);
f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking
Future.get() blockiert, und Sie können nicht einfach abhängige Operationen verketten oder Ergebnisse kombinieren — was CompletableFuture behebt.
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 ermöglicht es Ihnen, nicht-blockierende Pipelines zu erstellen — Transformationen (thenApply), Verkettung abhängiger Async-Aufrufe (thenCompose) und Fehlerbehandlung (exceptionally) — ohne Threads zu blockieren.
// 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 und anyOf koordinieren mehrere Async-Tasks elegant — unabhängige Arbeiten parallel ausgeführt und Ergebnisse kombiniert.
Das Executor-Framework und CompletableFuture sind die moderne, korrekte Art, Nebenläufigkeit und asynchrone Arbeiten in Java zu handhaben, die fehleranfällige manuelle Thread-Verwaltung ersetzend.
Thread-Pools (ExecutorService) vermeiden die Ressourcenerschöpfung und den Overhead der Erstellung eines Threads pro Task — essenziell für skalierbare Server.
CompletableFuture löst Futures Blockierungslimit durch Ermöglichung von kompozierbaren, nicht-blockierenden Pipelines, die asynchrone Operationen deklarativ verketten, transformieren, kombinieren und fehlerbehandeln — entscheidend für effiziente I/O-gebundene Services, die viele gleichzeitige Aufrufe koordinieren müssen (Datenbank, API, Microservices).
Das Verständnis dieser (über rohen Threads und blockierenden Futures) ist fundamental für das Erstellen performanter, skalierbarer nebenläufiger Java-Anwendungen und ist eine Schlüsselkompetenz auf Senior-Ebene.
Eine Sammlung von IT-Interviewfragen mit ausführlichen Antworten — vom Junior bis zum Senior.
Spenden