Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / Java

ThreadPoolExecutor: ograničeni skup i CallerRunsPolicy

ThreadPoolExecutor upravlja skupom dretvi i redom čekanja zadataka. Saznajte kada stvara dretve ili stavlja zadatke u red, kako ThreadPoolExecutor.CallerRunsPolicy postupa pri preopterećenju te kako shutdown() i awaitTermination() omogućuju uredan završetak.

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

Sintaksa

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

ThreadPoolExecutor izvršava zadatke pomoću dretvi iz skupa. Pri predaji zadatka stvara dretvu ako je broj radnih dretvi manji od corePoolSize; inače pokušava staviti zadatak u red. Kad je red pun, može stvarati dretve do ograničenja maximumPoolSize, a zatim primjenjuje pravilo odbijanja. Neograničeni red obično sprečava rast iznad corePoolSize i može gomilati neograničen broj zadataka na čekanju.

ThreadPoolExecutor.CallerRunsPolicy sinkrono izvršava odbijeni zadatak u dretvi koja poziva execute, osim ako je executor ugašen. To usporava proizvođača zadataka, ali može, primjerice, blokirati dretvu koja obrađuje zahtjeve. Ograničenje skupa ne uključuje ova izvršavanja u dretvi pozivatelja. Nakon gašenja ovo pravilo tiho odbacuje zadatak umjesto da baci iznimku, pa ne jamči njegovo izvršavanje.

ThreadPoolExecutor.shutdown pokreće uredno gašenje: prethodno prihvaćeni zadaci izvršavaju se, ali novi se ne prihvaćaju. Metoda ne čeka završetak; za to služi awaitTermination, čiji rezultat treba provjeriti. shutdownNow() samo pokušava prekinuti dretve, pa zadaci moraju reagirati na prekide. Primjer koristi mehanizam sinkronizacije umjesto kašnjenja kako bi izazvao preopterećenje. Opseg: Java SE 21; okruženje izvođenja repozitorija nije potvrđeno, kao ni produkcijsko okruženje.

Primjeri

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

Rezultat

caller thread: true
completed: 3

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

Izvori