Classe ThreadPoolExecutor

java.util.concurrent.ThreadPoolExecutor é um ExecutorService para executar cada tarefa enviada usando um dos vários encadeamentos em pool, normalmente configurados usando os métodos de fábrica do Executors. Ele também fornece vários métodos utilitários para verificar as estatísticas dos threads atuais e controlá-los.

Métodos ThreadPoolExecutor

Sr. Não. Método e Descrição
1

protected void afterExecute(Runnable r, Throwable t)

Método invocado após a conclusão da execução do Runnable fornecido.
2

void allowCoreThreadTimeOut(boolean value)

Define a política que rege se os threads principais podem atingir o tempo limite e terminar se nenhuma tarefa chegar dentro do tempo de manutenção de atividade, sendo substituídos, se necessário, quando novas tarefas chegarem.
3

boolean allowsCoreThreadTimeOut()

Retorna verdadeiro se este pool permitir que os threads principais expirem e terminem se nenhuma tarefa chegar dentro do tempo keepAlive, sendo substituídos se necessário quando novas tarefas chegarem.
4

boolean awaitTermination(long timeout, TimeUnit unit)

Bloqueia até que todas as tarefas tenham concluído a execução após uma solicitação de desligamento, ou o tempo limite ocorra ou o thread atual seja interrompido, o que ocorrer primeiro.
5

protected void beforeExecute(Thread t, Runnable r)

Método invocado antes de executar o Runnable fornecido no thread fornecido.
6

void execute(Runnable command)

Executa a tarefa fornecida em algum momento no futuro.
7

protected void finalize()

Invoca o desligamento quando este executor não é mais referenciado e não tem threads.
8

int getActiveCount()

Retorna o número aproximado de threads que estão executando tarefas ativamente.
9

long getCompletedTaskCount()

Retorna o número total aproximado de tarefas que concluíram a execução.
10

int getCorePoolSize()

Retorna o número principal de threads.
11

long getKeepAliveTime(TimeUnit unit)

Retorna o tempo de manutenção da atividade do encadeamento, que é a quantidade de tempo que os encadeamentos em excesso do tamanho do pool principal podem permanecer inativos antes de serem encerrados.
12

int getLargestPoolSize()

Retorna o maior número de threads que já estiveram simultaneamente no pool.
13

int getMaximumPoolSize()

Retorna o número máximo permitido de threads.
14

int getPoolSize()

Retorna o número atual de threads no pool.
15

BlockingQueue getQueue()

Retorna a fila de tarefas usada por este executor.
15

RejectedExecutionHandler getRejectedExecutionHandler()

Retorna o manipulador atual para tarefas não executáveis.
16

long getTaskCount()

Retorna o número total aproximado de tarefas que já foram agendadas para execução.
17

ThreadFactory getThreadFactory()

Retorna a fábrica de threads usada para criar novas threads.
18

boolean isShutdown()

Retorna verdadeiro se este executor foi desligado.
19

boolean isTerminated()

Retorna verdadeiro se todas as tarefas foram concluídas após o desligamento.
20

boolean isTerminating()

Retorna verdadeiro se este executor está em processo de encerramento após shutdown () ou shutdownNow (), mas não foi encerrado completamente.
21

int prestartAllCoreThreads()

Inicia todos os threads principais, fazendo com que esperem ociosamente pelo trabalho.
22

boolean prestartCoreThread()

Inicia um thread principal, fazendo com que ele espere ociosamente pelo trabalho.
23

void purge()

Tenta remover da fila de trabalho todas as tarefas futuras que foram canceladas.
24

boolean remove(Runnable task)

Remove esta tarefa da fila interna do executor se estiver presente, fazendo com que não seja executada se ainda não tiver sido iniciada.
25

void setCorePoolSize(int corePoolSize)

Define o número principal de threads.
26

void setKeepAliveTime(long time, TimeUnit unit)

Define o limite de tempo durante o qual os threads podem permanecer inativos antes de serem encerrados.
27

void setMaximumPoolSize(int maximumPoolSize)

Define o número máximo permitido de threads.
28

void setRejectedExecutionHandler(RejectedExecutionHandler handler)

Define um novo manipulador para tarefas não executáveis.
29

void setThreadFactory(ThreadFactory threadFactory)

Define a fábrica de linhas usada para criar novas linhas.
30

void shutdown()

Inicia um desligamento ordenado no qual as tarefas enviadas anteriormente são executadas, mas nenhuma tarefa nova será aceita.
31

List<Runnable> shutdownNow()

Tenta parar todas as tarefas em execução ativa, interrompe o processamento das tarefas em espera e retorna uma lista das tarefas que estavam aguardando execução.
32

protected void terminated()

Método invocado quando o Executor é encerrado.
33

String toString()

Retorna uma string que identifica este pool, bem como seu estado, incluindo indicações de estado de execução e contagens estimadas de trabalhadores e tarefas.

Exemplo

O seguinte programa TestThread mostra o uso da interface ThreadPoolExecutor em um ambiente baseado em thread.

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThread {
	
   public static void main(final String[] arguments) throws InterruptedException {
      ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();

      //Stats before tasks execution
      System.out.println("Largest executions: "
         + executor.getLargestPoolSize());
      System.out.println("Maximum allowed threads: "
         + executor.getMaximumPoolSize());
      System.out.println("Current threads in pool: "
         + executor.getPoolSize());
      System.out.println("Currently executing threads: "
         + executor.getActiveCount());
      System.out.println("Total number of threads(ever scheduled): "
         + executor.getTaskCount());

      executor.submit(new Task());
      executor.submit(new Task());

      //Stats after tasks execution
      System.out.println("Core threads: " + executor.getCorePoolSize());
      System.out.println("Largest executions: "
         + executor.getLargestPoolSize());
      System.out.println("Maximum allowed threads: "
         + executor.getMaximumPoolSize());
      System.out.println("Current threads in pool: "
         + executor.getPoolSize());
      System.out.println("Currently executing threads: "
         + executor.getActiveCount());
      System.out.println("Total number of threads(ever scheduled): "
         + executor.getTaskCount());

      executor.shutdown();
   }  

   static class Task implements Runnable {

      public void run() {

         try {
            Long duration = (long) (Math.random() * 5);
            System.out.println("Running Task! Thread Name: " +
               Thread.currentThread().getName());
            TimeUnit.SECONDS.sleep(duration);
            System.out.println("Task Completed! Thread Name: " +
               Thread.currentThread().getName());
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }
}

Isso produzirá o seguinte resultado.

Resultado

Largest executions: 0
Maximum allowed threads: 2147483647
Current threads in pool: 0
Currently executing threads: 0
Total number of threads(ever scheduled): 0
Core threads: 0
Largest executions: 2
Maximum allowed threads: 2147483647
Current threads in pool: 2
Currently executing threads: 2
Total number of threads(ever scheduled): 2
Running Task! Thread Name: pool-1-thread-2
Running Task! Thread Name: pool-1-thread-1
Task Completed! Thread Name: pool-1-thread-1
Task Completed! Thread Name: pool-1-thread-2