Executor framework र CompletableFuture ले async काम गर्नमा कसरी मदद गर्छन्?

Question

Accepted Answer

**Executor framework** ले thread को pool लाई व्यवस्थापन गर्छ ताकि तपाइँ *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()` ले block गर्छ, र तपाइँ सजिलै साथ निर्भर 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`) — thread लाई 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 लाई gracefully coordinate गर्छन् — independent काम लाई parallel मा चलाउदै र results लाई combine गर्दै। ## यो महत्त्वपूर्ण किन हो Executor framework र CompletableFuture Java मा concurrency र asynchronous काम लाई handle गर्नको **आधुनिक, सही तरिका** हुन्, error-prone manual thread management को स्थान लिदै। Thread pools (ExecutorService) ले resource exhaustion र एक task प्रति thread सिर्जना गर्नको overhead टाल्छन् — scalable servers को लागि आवश्यक। CompletableFuture ले Future को blocking limitation लाई **composable, non-blocking pipelines** सक्षम गरेर समाधान गर्छ जो chain, transform, combine, र error-handle async operations लाई declaratively गर्छन् — efficient I/O-bound services को लागि महत्त्वपूर्ण जो धेरै concurrent calls (database, API, microservices) लाई coordinate गर्नु पर्छ। यी (raw threads र blocking Futures को सट्टा) लाई बुझ्नु performant, scalable concurrent Java applications बनाउनको लागि fundamental हो र यो एक key senior-level competency हो।