Az Executor keretrendszer szálkészleteket kezel, így feladatokat küldöd be ahelyett, hogy manuálisan hoznál létre szálakat, és a CompletableFuture deklaratívan összeállít aszinkron műveleteket. Együtt ezek a modern módja az egyidejű/aszinkron munkavégzésnek Java-ban — elkerülöd a nyers szálkezelés költségét és bonyolultságát.
(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
Az ExecutorService szétválasztja a mit (feladatok) a hogyan-tól (szálkezelés) — egy korlátozott szálkészletet használ fel újra, megakadályozva az erőforrások kimerülését és a folyamatos szálkészítés terheit.
Future<Integer> f = executor.submit(task);
f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking
A Future.get() blokkolódik, és nem tudsz könnyen összekapcsolni függő műveleteket vagy kombinálni az eredményeket — ezt oldja meg a 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
A CompletableFuture lehetővé teszi nem-blokkoló csatornák felépítését — átalakítást (thenApply), függő aszinkron hívások láncolását (thenCompose), és hibakezelést (exceptionally) — szálak blokkolása nélkül.
// 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
A thenCombine, allOf és anyOf elegánsan koordinálnak több aszinkron feladatot — független munka párhuzamos futtatásával és eredmények kombinálásával.
Az Executor keretrendszer és a CompletableFuture az modern, helyes módja az egyidejűség és az aszinkron munka kezelésének Java-ban, helyettesítve a hibákat generáló kézi szálkezelést.
A szálkészletek (ExecutorService) elkerülik az erőforrások kimerülését és a szálanként egy szál létrehozásának terheit — elengedhetetlen a skálázható szerverekhez.
A CompletableFuture megoldja a Future blokkoló korlátját azáltal, hogy lehetővé teszi az összeállítható, nem-blokkoló csatornákat, amelyek deklaratívan láncol, átalakít, kombinál és hibákat kezelnek az aszinkron műveleteknek — döntő fontosságú az I/O-kötöttségű szolgáltatásokhoz, amelyeknek sok egyidejű hívást kell koordinálniuk (adatbázis, API, mikroszolgáltatások).
E megértése (a nyers szálakkal és a blokkoló Future-ökkel szemben) alapvető a teljesítményes, skálázható egyidejű Java-alkalmazások felépítéséhez, és ez egy kulcsfontosságú senior szintű kompetencia.