Executor framework threads کے pools کو manage کرتی ہے تاکہ آپ threads کو manually بنانے کی بجائے tasks submit کریں، اور CompletableFuture asynchronous operations کو declaratively compose کرتی ہے۔ یہ دونوں مل کر Java میں concurrent/async کام کا modern طریقہ ہیں — raw thread management کی لاگت اور complexity سے بچتے ہوئے۔
(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 کیا (tasks) کو کیسے (thread management) سے الگ کرتا ہے — یہ threads کے bounded pool کو reuse کرتا ہے، resource exhaustion اور thread creation کی constant overhead سے بچاتے ہوئے۔
Future<Integer> f = executor.submit(task);
f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking
Future.get() blocks کرتا ہے، اور آپ آسانی سے dependent operations کو chain نہیں کر سکتے یا results کو combine نہیں کر سکتے — جسے 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 بنانے دیتی ہے — transforming (thenApply)، dependent async calls کو chaining (thenCompose)، اور errors کو handle کرتے ہوئے (exceptionally) — بغیر threads کو block کیے۔
// 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 متعدد async tasks کو elegantly coordinate کرتے ہیں — independent work کو parallel میں چلاتے ہوئے اور results کو combine کرتے ہوئے۔
Executor framework اور CompletableFuture Java میں concurrency اور asynchronous کام کو handle کرنے کا modern، صحیح طریقہ ہیں، error-prone manual thread management کی جگہ لیتے ہوئے۔
Thread pools (ExecutorService) resource exhaustion اور ہر task کے لیے thread بنانے کی overhead سے بچاتے ہیں — scalable servers کے لیے ضروری ہے۔
CompletableFuture Future کی blocking limitation کو composable، non-blocking pipelines کو enable کر کے حل کرتی ہے جو async operations کو declaratively chain، transform، combine، اور error-handle کرتے ہیں — efficient I/O-bound services کے لیے crucial ہیں جنہیں بہت سی concurrent calls (database، API، microservices) کو coordinate کرنا ہوتا ہے۔
ان کو سمجھنا (raw threads اور blocking Futures کے بجائے) performant، scalable concurrent Java applications بنانے کے لیے fundamental ہے اور senior-level competency کا اہم حصہ ہے۔
تفصیلی جوابات کے ساتھ IT انٹرویو سوالات کی ایک لائبریری — جونیئر سے سینئر تک۔
عطیہ دیں