Bainistríonn an creat Executor pools de snáitheanna ionas gur cuireann tú tascanna isteach in ionad snáitheanna a chruthú de láimh, agus tugann CompletableFuture cumhacht do dhéanamh oibríochtaí neamhshincronach ar bhealach dearbhach. Le chéile, siad an bealach nua-aimseartha a dhéanamh oibair dhomhanda/aschuallach i Java — ag seachaint an chósta agus an chastachta a bhaineann le bainistiú snáitheanna amh.
// ❌ 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
}
// ✅ 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
Dealáíonn ExecutorService idir an céard (tascanna) agus an conas (bainistiú snáitheanna) — athúsáideann sé pool teorannaithe de snáitheanna, ag cosc ar dhíothú acmhainní agus ar bharrachas ghréine snáitheanna a chruthú i rith an ama.
Future<Integer> f = executor.submit(task);
f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking
Cuireann Future.get() bac ar obair, agus ní féidir leat a bheith i do dhiaidh oibríochtaí spleácha ná torthaí a chomhcheangal go héasca — sin é an rud a leagann CompletableFuture síos.
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
Ligean do CompletableFuture duit píoplaí neamhbhachach a thógáil — athrú (thenApply), slabhraí ghlaocanna aschuallach spleácha (thenCompose), agus láimhseáil earráidí (exceptionally) — gan snáitheanna a chur faoi bhac.
// 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
Tugann thenCombine, allOf, agus anyOf comhordú ar thascanna aschuallach iolracha ar bhealach galánta — obair neamhspleách ar fheidhmiú go comhthreomhar agus torthaí a chomhcheangal.
Is é an creat Executor agus CompletableFuture an bealach nua-aimseartha, ceart a dhéileáil le comhthreomharú agus obair aschuallach i Java, ag ionadú bainistithe snáitheanna amh a bhí ina bhagairt earráidí.
Seachnaíonn pools snáitheanna (ExecutorService) díothú acmhainní agus barrachas a bhaineann le snáithe a chruthú in aghaidh an tasc — riachtanach do bhogsuim inrochtana.
Réitíonn CompletableFuture teorannú bac Future trí píoplaí cumscríobh, neamhbhachach a chumasú a slabhraíonn, a athraíonn, a chomhcheangaíonn, agus a láimhsíonn earráidí oibríochtaí aschuallach ar bhealach dearbhach — ríthábhachtach do sheirbhísí foluain I/O a chaithfidh go leor glaocanna comhthreomharacha a chomhordú (bunachar sonraí, API, microservices).
Tá tuiscint ar na nithe seo (os cionn snáitheanna amh agus Futures bacacha) bunúsach do thógáil feidhmchlár Java comhthreomhar, ináirithe agus is é seo ar dheis dheas-leibhéal.