Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / Java

ExecutorService — opravila, rezultati in zaustavitev

ExecutorService ločuje oddajo opravil od upravljanja njihovega izvajanja. Spoznajte submit, paketno izvajanje z invokeAll in shutdown ter razliko med zahtevo za zaustavitev in čakanjem na zaključek.

Različica: Java SE 21 (repository runtime); production runtime not attested

Sintaksa

<T> Future<T> submit(Callable<T> task)
Future<?> submit(Runnable task)
<T> Future<T> submit(Runnable task, T result)
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException
void shutdown()

java.util.concurrent.ExecutorService razširi Executor s sledenjem rezultatom in upravljanjem zaključka. Ta vnos obravnava Java SE 21, ki jo repozitorij uporablja kot izvajalno okolje. Produkcijsko izvajalno okolje ni potrjeno.

ExecutorService.submit vrne Future: pri Callable<T> zagotavlja rezultat opravila, pri Runnable je rezultat null, pri submit(Runnable, T) pa je rezultat podana vrednost. Future.get() po potrebi počaka; napako opravila sporoči kot ExecutionException, preklic kot CancellationException, prekinitev med čakanjem pa kot InterruptedException.

ExecutorService.invokeAll brez časovne omejitve počaka, da se zaključijo vsa opravila Callable. Vrnjeni futures ohranijo vhodni vrstni red, ne vrstnega reda zaključevanja. Zaključek ne pomeni uspeha: rezultate in napake pridobite z get().

ExecutorService.shutdown zavrne nova opravila, omogoči izvedbo že sprejetih opravil in ne čaka. Za čakanje uporabite awaitTermination; v Java SE 21 close() v try-with-resources zaustavi storitev in počaka. Izrecni shutdown() v primeru prikazuje API, vendar je zaradi close() odveč. Dolgotrajna opravila lahko upočasnijo zapiranje.

Primer uporablja Executors.newFixedThreadPool(2). Ta tovarna ima neomejeno čakalno vrsto: dve niti ne omejujeta števila čakajočih opravil. Ne obravnavajte je kot samodejno zaščito pred preobremenitvijo.

Primeri

import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
    public static void main(String[] args) throws Exception {
        try (ExecutorService pool = Executors.newFixedThreadPool(2)) {
            Future<Integer> single = pool.submit(() -> 6 * 7);
            List<Callable<Integer>> tasks = List.of(() -> 2 + 3, () -> 4 * 5);
            List<Future<Integer>> batch = pool.invokeAll(tasks);
            pool.shutdown();

            System.out.println(single.get());
            for (Future<Integer> result : batch) {
                System.out.println(result.get());
            }
        }
    }
}

Rezultat

42
5
20

Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.

Viri