Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

ThreadPoolExecutor: ograniczona pula i CallerRunsPolicy

ThreadPoolExecutor zarządza pulą wątków i kolejką zadań. Poznaj kolejność tworzenia wątków i kolejkowania, zachowanie ThreadPoolExecutor.CallerRunsPolicy przy przeciążeniu oraz bezpieczne kończenie pracy przez shutdown() i awaitTermination().

Wersja: Java SE 21; repository runtime, production runtime not attested

Składnia

new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new ThreadPoolExecutor.CallerRunsPolicy());
executor.execute(task);
executor.shutdown();
executor.awaitTermination(timeout, unit);

ThreadPoolExecutor wykonuje zadania przy użyciu puli wątków. Przy zgłoszeniu zadania tworzy wątek, jeśli liczba pracowników jest mniejsza niż corePoolSize; w przeciwnym razie próbuje kolejkowania. Gdy kolejka jest pełna, może utworzyć wątek do limitu maximumPoolSize, a następnie stosuje politykę odrzucania. Nieograniczona kolejka zwykle uniemożliwia wzrost ponad corePoolSize i może gromadzić zadania bez ograniczenia.

ThreadPoolExecutor.CallerRunsPolicy wykonuje odrzucone zadanie synchronicznie w wątku wywołującym execute, o ile executor nie został zamknięty. Spowalnia to producenta zadań, ale może blokować np. wątek obsługi żądania. Limit puli nie obejmuje tych wykonań w wątkach wywołujących. Po zamknięciu ta polityka pomija zadanie bez wyjątku — nie gwarantuje więc jego wykonania.

ThreadPoolExecutor.shutdown rozpoczyna uporządkowane zamykanie: wcześniej przyjęte zadania są wykonywane, nowe nie są przyjmowane. Metoda nie czeka na zakończenie; służy do tego awaitTermination, którego wynik trzeba sprawdzić. shutdownNow() jedynie próbuje przerwać pracę, więc zadania muszą reagować na przerwania. Przykład używa zatrzasku zamiast opóźnień, aby wymusić przeciążenie. Zakres opisu: Java SE 21; środowisko repozytorium, środowisko produkcyjne niepotwierdzone.

Przykłady

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch release = new CountDownLatch(1);
        AtomicInteger completed = new AtomicInteger();
        Thread caller = Thread.currentThread();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                1, 1, 0L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(1),
                new ThreadPoolExecutor.CallerRunsPolicy());

        try {
            executor.execute(() -> {
                try {
                    release.await();
                    completed.incrementAndGet();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            executor.execute(() -> completed.incrementAndGet());
            executor.execute(() -> {
                System.out.println("caller thread: "
                        + (Thread.currentThread() == caller));
                completed.incrementAndGet();
            });
        } finally {
            release.countDown();
            executor.shutdown();
        }

        try {
            if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                executor.shutdownNow();
                throw new IllegalStateException("Termination timed out");
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
            throw e;
        }
        System.out.println("completed: " + completed.get());
    }
}

Wynik

caller thread: true
completed: 3

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła