Executor framework اور CompletableFuture async کام میں کس طرح مدد کرتے ہیں؟

Question

Accepted Answer

**Executor framework** threads کے pools کو manage کرتی ہے تاکہ آپ threads کو manually بنانے کی بجائے *tasks* submit کریں، اور **`CompletableFuture`** asynchronous operations کو declaratively compose کرتی ہے۔ یہ دونوں مل کر Java میں concurrent/async کام کا modern طریقہ ہیں — raw thread management کی لاگت اور complexity سے بچتے ہوئے۔ ## raw threads کے ساتھ مسئلہ ```java // ❌ 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 } ``` ## ExecutorService — managed thread pools ```java // ✅ a fixed pool reuses a bounded set of threads for many tasks ExecutorService executor = Executors.newFixedThreadPool(10); Future 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 کی محدودیت ```java Future 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 — composable async ```java 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 کیے۔ ## متعدد async operations کو یکجا کرنا ```java // run two independent async calls in PARALLEL and combine their results CompletableFuture userF = CompletableFuture.supplyAsync(() -> fetchUser(id)); CompletableFuture 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 کا اہم حصہ ہے۔