Executor ఫ్రేమ్వర్క్ థ్రెడ్ల పూల్లను నిర్వహిస్తుంది తద్వారా మీరు tasksను సమర్పించండి బదులుగా థ్రెడ్లను మానవీయంగా సృష్టించటానికి, మరియు CompletableFuture అసింక్రონస్ ఆపరేషన్లను ప్రకటనాత్మకంగా కంపోజ్ చేస్తుంది. కలిసి అవి Java లో సమకాలీన/అసింక్రონస్ పనిని చేయడానికి ఆధునిక మార్గం — ముడి థ్రెడ్ నిర్వహణ యొక్క ఖర్చు మరియు సంక్లిష్టతను నివారించటానికి.
(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 what (tasks)ను how (థ్రెడ్ నిర్వహణ) నుండి వేరు చేస్తుంది — ఇది థ్రెడ్ల సరిహద్దు పూల్ను పునర్వినియోగం చేస్తుంది, వనరుల అయోమయం మరియు నిరంతర థ్రెడ్ సృష్టి యొక్క ఓవరహెడ్ను నిరోధిస్తుంది.
Future<Integer> f = executor.submit(task);
f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking
Future.get() బ్లాక్ చేస్తుంది, మరియు మీరు సులభంగా ఆధారిత ఆపరేషన్లను చేయలేరు లేదా ఫలితాలను కలపలేరు — ఇది 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 మీరు non-blocking pipelines నిర్మించుకోవడానికి అనుమతిస్తుంది — రూపాంతరం (thenApply), ఆధారిత అసింక్రონస్ కాల్లను చేయటం (thenCompose), మరియు errors (exceptionally) నిర్వహించటం — థ్రెడ్లను బ్లాక్ చేయకుండా.
// 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, మరియు anyOf బహుళ అసింక్రონస్ tasks ను సూక్ష్మంగా సమన్వయం చేస్తాయి — స్వతంత్ర కర్మను సమాంతరంగా అమలు చేస్తూ మరియు ఫలితాలను కలుపుతూ.
Executor ఫ్రేమ్వర్క్ మరియు CompletableFuture Java లో సమకాలీనత మరియు అసింక్రონస్ పనిని నిర్వహించడానికి ఆధునిక, సరైన మార్గం — దోషచిత్తమైన ముడి థ్రెడ్ నిర్వహణను భర్తీ చేస్తాయి.
థ్రెడ్ పూల్లు (ExecutorService) వనరుల అయోమయం మరియు ప్రతి task కోసం థ్రెడ్ను సృష్టించటం యొక్క ఓవరహెడ్ నుండి నివారించాయి — స్కేలేబల్ సర్వర్ల కోసం అవసరం.
CompletableFuture Future యొక్క blocking పరిమితిని సాధిస్తుంది composable, non-blocking pipelines ను ప్రారంభించటం ద్వారా అసింక్రონస్ ఆపరేషన్లను చేయటం, రూపాంతరం, కలుపుటం, మరియు error-నిర్వహణ ప్రకటనాత్మకంగా — కార్యকరమైన I/O-bound సేవల కోసం అవసరం అనేక సమకాలీన కాల్లను సమన్వయం చేయాలి (database, API, microservices).
ఈ విషయాలను అర్థం చేసుకోవటం (ముడి థ్రెడ్లు మరియు blocking Futures కంటే) కార్యకరమైన, స్కేలేబల్ సమకాలీన Java అనువర్తనాలను నిర్మించటానికి ప్రాథమికమైనది మరియు సీనియర్-స్థర పౌండ్యం.