Executor framework અને CompletableFuture async કાર્ય માટે કેવી રીતે મદદ કરે છે?

Question

Accepted Answer

**Executor framework** થ્રેડ્સના પુલને વ્યવસ્થાપિત કરે છે તેથી તમે હાથથી થ્રેડ્સ બનાવવાને બદલે *કાર્યો* સબમિટ કરો છો, અને **`CompletableFuture`** વિજ્ઞાપનાત્મક રીતે અસમકાલિક ક્રિયાકલાપોને સંયોજિત કરે છે. એક સાથે તેઓ Java માં સમવર્તી/અસમકાલિક કાર્ય કરવાનો આધુનિક માર્ગ છે — કાચા થ્રેડ વ્યવસ્થાપનની કિંમત અને જટિલતા ટાળીને. ## કાચા થ્રેડ્સ સાથે સમસ્યા ```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 — વ્યવસ્થાપિત થ્રેડ પુલ્સ ```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` *શું* (કાર્યો) ને *કેવી રીતે* (થ્રેડ વ્યવસ્થાપન) થી અલગ કરે છે — તે થ્રેડ્સના બાંધેલ પુલને પુનઃવાપરે છે, સંસાધનોના અધોગતિ અને સતત થ્રેડ નિર્માણના ઓવરહેડને રોકે છે. ## Future ની મર્યાદા ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` અવરોધ કરે છે, અને તમે સરળતાથી આશ્રિત કાર્યોને શૃંખલીબદ્ધ કરી શકતા નથી અથવા પરિણામોને જોડી શકતા નથી — જે `CompletableFuture` સુધારે છે. ## CompletableFuture — સંયોજનક્ષમ અસમકાલિક ```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` તમને **બિન-અવરોધક પાઇપલાઇનો** બનાવવાની અનુમતિ આપે છે — રૂપાંતર (`thenApply`), આશ્રિત અસમકાલિક કૉલોને શૃંખલીબદ્ધ કરવું (`thenCompose`), અને ભૂલો સંભાળવી (`exceptionally`) — થ્રેડ્સને અવરોધ્યા વિના. ## બહુવિધ અસમકાલિક ક્રિયાકલાપોને જોડવું ```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` બહુવિધ અસમકાલિક કાર્યોને સુંદર રીતે સંકલિત કરે છે — સ્વતંત્ર કાર્યને સમાંતરમાં ચલાવે છે અને પરિણામોને સંયોજિત કરે છે. ## તે શા માટે મહત્વપૂર્ણ છે Executor framework અને CompletableFuture Java માં સમવર્તિતા અને અસમકાલિક કાર્ય સંભાળવાનો **આધુનિક, સાચો રસ્તો** છે, ભૂલ-સંભવિત હાથી થ્રેડ વ્યવસ્થાપનને બદલીને. થ્રેડ પુલ્સ (ExecutorService) પ્રતિ કાર્ય એક થ્રેડ બનાવવાના સંસાધન અધોગતિ અને ઓવરહેડ ટાળે છે — માપી શકાય તેવા સર્વર્સ માટે આવશ્યક છે. CompletableFuture Future ની અવરોધક મર્યાદા સુધારે છે વિજ્ઞાપનાત્મક રીતે અસમકાલિક કાર્યોને શૃંખલીબદ્ધ, રૂપાંતર, જોડવા અને ભૂલ-સંભાળવા માટે **સંયોજનક્ષમ, બિન-અવરોધક પાઇપલાઇનો** સક્ષમ કરીને — I/O-બાધ્ય સેવાઓ માટે નિર્ણાયક જે ઘણા સમવર્તી કૉલોને સમન્વય કરવા જોઈએ (ડેટાબેસ, API, માઇક્રોસર્વિસ). આ (કાચા થ્રેડ્સ અને અવરોધક Futures ઉપર) સમજવું હાથી શક્તિશાળી, માપી શકાય તેવા સમવર્તી Java એપ્લિકેશનો બનાવવા માટે મૂળભૂત છે અને તે વરિષ્ઠ-સ્તરની સક્ષમતા છે.