Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / Java

ExecutorService — zadaci, rezultati i gašenje

ExecutorService odvaja predaju zadataka od upravljanja njihovim izvršavanjem. Upoznajte submit, skupno izvršavanje pomoću invokeAll i shutdown te razliku između zahtjeva za gašenje i čekanja na završetak.

Verzija: 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 proširuje Executor praćenjem rezultata i upravljanjem završetkom. Ovaj se članak odnosi na Java SE 21, koju repozitorij koristi kao okruženje za izvođenje. Okruženje za izvođenje u produkciji nije potvrđeno.

ExecutorService.submit vraća Future: za Callable<T> pruža rezultat zadatka, za Runnable je rezultat null, a za submit(Runnable, T) to je zadana vrijednost. Future.get() po potrebi čeka; pogrešku zadatka prijavljuje kao ExecutionException, otkazivanje kao CancellationException, a prekid tijekom čekanja kao InterruptedException.

ExecutorService.invokeAll bez vremenskog ograničenja čeka da se svi zadaci Callable dovrše. Vraćeni futures zadržavaju ulazni redoslijed, a ne redoslijed dovršetka. Dovršetak ne znači uspjeh: rezultate i pogreške dohvatite pomoću get().

ExecutorService.shutdown odbija nove zadatke, omogućuje izvršavanje prethodno prihvaćenih zadataka i ne čeka. Za čekanje upotrijebite awaitTermination; u Java SE 21 close() u try-with-resources gasi uslugu i čeka. Izričiti shutdown() u primjeru prikazuje API, ali je zbog close() suvišan. Dugotrajni zadaci mogu odgoditi zatvaranje.

Primjer upotrebljava Executors.newFixedThreadPool(2). Ta tvornica ima neograničen red čekanja: dvije dretve ne ograničavaju broj zadataka na čekanju. Nemojte je smatrati automatskom zaštitom od preopterećenja.

Primjeri

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

Prikazani kôd i navedeni rezultat provjereni su u izoliranom okruženju metodom zabilježenom u dokazu provjere za ovu točnu verziju.

Izvori