Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

ThreadPoolExecutor: omezený fond a CallerRunsPolicy

ThreadPoolExecutor spravuje fond vláken a frontu úloh. Zjistěte, kdy vytváří vlákna nebo zařazuje úlohy do fronty, jak ThreadPoolExecutor.CallerRunsPolicy řeší přetížení a jak shutdown() a awaitTermination() podporují řádné ukončení.

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

Syntaxe

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

ThreadPoolExecutor spouští úlohy pomocí vláken ve fondu. Při odeslání úlohy vytvoří vlákno, pokud je počet pracovních vláken menší než corePoolSize; jinak se pokusí úlohu zařadit do fronty. Když je fronta plná, může vytvořit vlákno až do limitu maximumPoolSize a poté použije zásadu odmítání. Neomezená fronta obvykle brání růstu nad corePoolSize a může hromadit neomezený počet čekajících úloh.

ThreadPoolExecutor.CallerRunsPolicy spustí odmítnutou úlohu synchronně ve vlákně, které volá execute, pokud executor nebyl ukončen. Tím se zpomalí producent úloh, ale může se například zablokovat vlákno obsluhující požadavek. Limit fondu tyto úlohy spuštěné ve volajícím vlákně nezahrnuje. Po ukončení tato zásada úlohu tiše zahodí, místo aby vyvolala výjimku; její spuštění tedy nezaručuje.

ThreadPoolExecutor.shutdown zahájí řádné ukončení: dříve přijaté úlohy se provedou, nové úlohy se už nepřijímají. Metoda nečeká na dokončení; k tomu slouží awaitTermination, jehož výsledek je třeba zkontrolovat. shutdownNow() se pouze pokusí vlákna přerušit, takže úlohy musí na přerušení reagovat. Příklad používá synchronizační mechanismus místo prodlev, aby vyvolal přetížení. Rozsah: Java SE 21; běhové prostředí repozitáře není potvrzeno, stejně jako produkční prostředí.

Příklady

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());
    }
}

Výsledek

caller thread: true
completed: 3

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje