Si bëjnë Executor framework-u dhe CompletableFuture ndihmën me punën asinkrone?

Question

Accepted Answer

**Executor framework**-u menaxhon grupe thread-esh që ju të paraqitni *detyra* në vend se të krijoni manualisht thread-e, dhe **`CompletableFuture`** kompozon veprimet asinkrone në mënyrë deklarative. Së bashku ato janë mënyra moderne për të bërë punën konkurrente/asinkrone në Java — duke shmangur kostot dhe kompleksitetin e menaxhimit të raw thread-eve. ## Problemi me raw thread-et ```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 — grupe thread-esh të menaxhuara ```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 ``` Një `ExecutorService` ndan *çfarë* (detyrat) nga *si* (menaxhimi i thread-eve) — ai ripërdor një grup të kufizuar thread-esh, duke parandaluar shterimin e burimeve dhe kosto të vazhdueshme të krijimit të thread-eve. ## Limitimi i Future ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` bllokon, dhe ju nuk mund të zinxhironi lehtë veprimet e varura ose të kombinoni rezultatet — e cila është ajo që `CompletableFuture` rregullon. ## CompletableFuture — asinkrone të përbëra ```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` ju lejon të ndërtoni **pipeline-a jo-bllokues** — transformim (`thenApply`), zinxhirimi i thirrjeve asinkrone të varura (`thenCompose`), dhe menaxhim i gabimeve (`exceptionally`) — pa bllokuar thread-et. ## Kombinimi i operacioneve të shumta asinkrone ```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`, dhe `anyOf` koordinojnë detyrat e shumta asinkrone me elegancë — duke ekzekutuar punën e pavarur në paralelë dhe kombinuar rezultatet. ## Pse ka rëndësi Executor framework-u dhe CompletableFuture janë **mënyra moderne, e saktë** për të menaxhuar konkurencën dhe punën asinkrone në Java, duke zëvendësuar menaxhimin manual të thread-eve të prirur ndaj gabimeve. Grupet e thread-eve (ExecutorService) shmangen shterimin e burimeve dhe kostot e krijimit të një thread për çdo detyrë — thelbësor për serverë të shkallëzueshëm. CompletableFuture zgjidh limitimin e bllokimit të Future duke mundësuar **pipeline-a të përbëra, jo-bllokues** që zinxhirojnë, transformojnë, kombinojnë, dhe menaxhojnë gabime të operacioneve asinkrone në mënyrë deklarative — vendimtar për shërbime efikase të lidhura me I/O që duhet koordinojnë shumë thirrje konkurrente (bazë të dhënash, API, microservices). Shkuptimi i këtyre (përkundër raw thread-eve dhe Futures-eve bllokues) është themelor për ndërtimin e aplikacioneve konkurrente Java performante dhe të shkallëzueshme dhe është një kompetencë kyçe në nivel senior.