Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

ThreadPoolExecutor: pool limitado e CallerRunsPolicy

ThreadPoolExecutor gere um conjunto de threads e uma fila de tarefas. Saiba quando cria threads ou coloca tarefas na fila, como ThreadPoolExecutor.CallerRunsPolicy lida com a sobrecarga e como shutdown() e awaitTermination() permitem uma terminação ordenada.

Versão: Java SE 21; repository runtime, production runtime not attested

Sintaxe

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

ThreadPoolExecutor executa tarefas com threads reunidas num pool. Ao submeter uma tarefa, cria uma thread se o número de trabalhadores for inferior a corePoolSize; caso contrário, tenta colocá-la na fila. Quando a fila está cheia, pode criar threads até ao limite de maximumPoolSize e, em seguida, aplica a política de rejeição. Uma fila ilimitada normalmente impede o crescimento do pool para além de corePoolSize e pode acumular tarefas pendentes sem limite.

ThreadPoolExecutor.CallerRunsPolicy executa sincronamente uma tarefa rejeitada na thread que chama execute, a menos que o executor tenha sido encerrado. Isto abranda quem produz as tarefas, mas pode bloquear, por exemplo, uma thread que trata pedidos. O limite do pool não inclui estas execuções na thread chamadora. Após o encerramento, esta política descarta a tarefa sem aviso, em vez de lançar uma exceção; por isso, não garante a sua execução.

ThreadPoolExecutor.shutdown inicia um encerramento ordenado: as tarefas aceites anteriormente são executadas, mas não são aceites novas tarefas. O método não espera pela conclusão; para isso, use awaitTermination e verifique o resultado. shutdownNow() apenas tenta interromper as threads, pelo que as tarefas têm de reagir às interrupções. O exemplo usa um mecanismo de sincronização em vez de atrasos para provocar sobrecarga. Âmbito: Java SE 21; o ambiente de execução do repositório não está certificado, tal como o ambiente de produção.

Exemplos

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

Resultado

caller thread: true
completed: 3

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes