L-Executor framework jimmaniġġja pools ta' threads sabiex tippreżenta tasks minflok ma' tiddħol u tħallaq threads manwalment, u CompletableFuture tikkomponi operazzjonijiet asinkrini b'mod deċlarattiv. Flimkien dawn huma l-mod modern biex tagħmel ħidma konkorrenti/asinkrina f'Java — iffrugaw il-kost u l-kumplessità tal-ġestjoni ta' threads grezzi.
(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 tissiepara l-xi (tasks) mid-kif (ġestjoni ta' threads) — terġa' tuża pool limitat ta' threads, u bħal dan tipprevjeni l-ħruq ta' riżorsi u l-overhead tal-ħolqien kostanti ta' threads.
Future<Integer> f = executor.submit(task);
f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking
Future.get() tblokkja, u ma tistax faċilment tgħaqqed operazzjonijiet dipendenti jew tikkombina riżultati — li hija dik li CompletableFuture tissolvi.
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 tħallak tibni pipelines mhux blokkaturi — tittrasfurma (thenApply), tgħaqqed sejħiet asinkrini dipendenti (thenCompose), u tġestixxi żbalji (exceptionally) — mingħajr ma' tblokka 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, u anyOf jikkordraw tasks multipli asinkrini b'eleganza — igħarrunaw xogħol indipendenti b'mod parallel u jikkombinaw riżultati.
L-Executor framework u CompletableFuture huma l-mod modern u korrett biex tgħaqqad l-konkorrenza u l-ħidma asinkrina f'Java, issostitwixxi l-ġestjoni manwali ta' threads li huwa pron għall-iżbalji.
Pools ta' threads (ExecutorService) iffrugaw il-ħruq ta' riżorsi u l-overhead tal-ħolqien ta' thread għal kull task — essenzjali għal servers skalabbli.
CompletableFuture tissolvi l-limitazzjoni ta' blokk ta' Future billi tippermetti pipelines komponibbli u mhux blokkaturi li jgħaqqdu, jittrasformaw, jikkombinaw, u jġestixxi żbalji ta' operazzjonijiet asinkrini b'mod deċlarattiv — kruċjali għal servizzi I/O-bound effettwi li jridu jikkordraw sejħiet konkorrenti multipli (database, API, microservices).
L-għarfien ta' dawn (aktar minn threads grezzi u Futures blokkaturi) huwa fundamentali biex tibni applikazzjonijiet Java konkorrenti performanti u skalabbli, u huwa kompetenzi ewlenija ta' livell senior.