Executor framework आणि CompletableFuture async काम करताना कसे मदत करतात?

Question

Accepted Answer

**Executor framework** threads च्या pools व्यवस्थापित करते जेणेकरून आप *tasks* submit करता (मॅन्युअल thread तयार करण्याऐवजी), आणि **`CompletableFuture`** asynchronous operations declaratively compose करते. एकत्रितपणे हे Java मधील concurrent/async काम करण्याचा आधुनिक मार्ग आहे — raw thread management च्या खर्च आणि जटिलतेस टाळते. ## 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 — व्यवस्थापित 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 ची पुनः वापरता, resource exhaustion आणि constant thread creation च्या 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 साखळीबद्ध करू शकत नाही किंवा results एकत्रित करू शकत नाही — जे `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 साखळीबद्ध करणे (`thenCompose`), आणि errors हाताळणे (`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 समन्वयिते — independent काम समांतरपणे चालवत आणि results एकत्रित करत. ## हे महत्वाचे का आहे Executor framework आणि CompletableFuture हे Java मधील concurrency आणि asynchronous काम हाताळण्याचा **आधुनिक, योग्य मार्ग** आहे, error-prone मॅन्युअल thread management ची जागा घेते. Thread pools (ExecutorService) task प्रति thread तयार करण्याचे resource exhaustion आणि overhead टाळते — scalable servers साठी आवश्यक आहे. CompletableFuture Future च्या blocking limitation निश्चित करते **composable, non-blocking pipelines** सक्षम करून जे async operations declaratively साखळीबद्ध करते, transform करते, एकत्रित करते, आणि error-handle करते — efficient I/O-bound services साठी महत्वाचे जे अनेक concurrent calls (database, API, microservices) समन्वयित करणे आवश्यक आहे. हे (raw threads आणि blocking Futures पेक्षा) समजणे performant, scalable concurrent Java applications तयार करण्यासाठी आधारभूत आहे आणि senior-level competency ची महत्वाची गोष्ट आहे.