Executor framework और CompletableFuture async काम में कैसे मदद करते हैं?

Question

IT Interview Practice · Accepted Answer

**Executor framework** threads के pools को प्रबंधित करता है ताकि आप manually threads बनाने के बजाय *tasks* submit करें, और **`CompletableFuture`** asynchronous operations को declaratively compose करता है। साथ में ये Java में concurrent/async काम करने का आधुनिक तरीका हैं — raw thread प्रबंधन की लागत और जटिलता से बचते हुए। ## 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 प्रबंधन) से अलग करता है — यह threads के एक bounded pool का पुनः उपयोग करता है, resource exhaustion और निरंतर thread निर्माण के overhead को रोकता है। ## Future की सीमा ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` block करता है, और आप आसानी से 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** बनाने देता है — transform करना (`thenApply`), dependent async calls को chain करना (`thenCompose`), और errors को handle करना (`exceptionally`) — threads को block किए बिना। ## कई async operations को combine करना ```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 को सुंदर ढंग से समन्वित करते हैं — स्वतंत्र काम को समानांतर में चलाते हुए और results को combine करते हुए। ## यह क्यों महत्वपूर्ण है Executor framework और CompletableFuture Java में concurrency और asynchronous काम को संभालने का **आधुनिक, सही तरीका** हैं, जो error-prone manual thread प्रबंधन की जगह लेते हैं। Thread pools (ExecutorService) प्रति task एक thread बनाने के resource exhaustion और overhead से बचते हैं — scalable servers के लिए आवश्यक। CompletableFuture **composable, non-blocking pipelines** को सक्षम करके Future की blocking सीमा का समाधान करता है जो async operations को declaratively chain, transform, combine, और error-handle करते हैं — कई समवर्ती calls (database, API, microservices) को समन्वित करने वाली efficient I/O-bound services के लिए महत्वपूर्ण। इन्हें समझना (raw threads और blocking Futures की तुलना में) performant, scalable concurrent Java applications बनाने के लिए मूलभूत है और एक प्रमुख senior-level दक्षता है।

raw threads की समस्या

ExecutorService — managed thread pools

Future की सीमा

CompletableFuture — composable async

कई async operations को combine करना

यह क्यों महत्वपूर्ण है

संबंधित प्रश्न