Executor framework husimamia pools za threads ili uwasilishe tasks badala ya kuunda threads mwenyewe, na CompletableFuture huunganisha operesheni za asynchronous kwa njia ya kutangaza. Kwa pamoja ni njia ya kisasa ya kufanya kazi za concurrent/async katika Java — ikiepuka gharama na utata wa usimamizi wa raw threads.
(Task t : tasks) {
(() -> process(t)).start();
}
// ✅ a fixed pool reuses a bounded set of threads for many tasks
ExecutorService executor = Executors.newFixedThreadPool(10);
Future<Integer> 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 hutenganisha nini (tasks) na jinsi gani (usimamizi wa threads) — hutumia tena pool yenye mipaka ya threads, ikizuia kuisha kwa rasilimali na overhead ya kuunda threads mara kwa mara.
Future<Integer> f = executor.submit(task);
f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking
Future.get() huzuia, na huwezi kwa urahisi kuunganisha operesheni tegemezi au kuchanganya matokeo — ambayo ndiyo CompletableFuture hurekebisha.
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 hukuwezesha kujenga non-blocking pipelines — kubadilisha (thenApply), kuunganisha async calls tegemezi (thenCompose), na kushughulikia errors (exceptionally) — bila kuzuia threads.
// run two independent async calls in PARALLEL and combine their results
CompletableFuture<User> userF = CompletableFuture.supplyAsync(() -> fetchUser(id));
CompletableFuture<Order> 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, na anyOf huratibu tasks nyingi za async kwa uzuri — kuendesha kazi huru kwa sambamba na kuchanganya matokeo.
Executor framework na CompletableFuture ni njia ya kisasa, sahihi ya kushughulikia concurrency na kazi ya asynchronous katika Java, zikibadilisha usimamizi wa raw threads wenye makosa.
Thread pools (ExecutorService) huepuka kuisha kwa rasilimali na overhead ya kuunda thread kwa kila task — muhimu kwa servers zinazopanuka.
CompletableFuture hutatua kikwazo cha kuzuia cha Future kwa kuwezesha composable, non-blocking pipelines zinazounganisha, kubadilisha, kuchanganya, na kushughulikia errors za operesheni za async kwa njia ya kutangaza — muhimu kwa services za I/O zinazohitaji kuratibu calls nyingi za concurrent (database, API, microservices).
Kuzielewa (badala ya raw threads na blocking Futures) ni jambo la msingi kwa kujenga programu za Java za concurrent zinazofanya kazi vizuri na kupanuka, na ni umahiri muhimu wa kiwango cha senior.