ThreadPoolExecutor (clase)

java.util.concurrent.ThreadPoolExecutor es un ExecutorService para ejecutar cada tarea enviada usando uno de posiblemente varios subprocesos agrupados, normalmente configurados usando los métodos de fábrica de Executors. También proporciona varios métodos de utilidad para verificar las estadísticas actuales de los hilos y controlarlos.

Métodos ThreadPoolExecutor

No Señor. Método y descripción
1

protected void afterExecute(Runnable r, Throwable t)

Método invocado al finalizar la ejecución del Runnable dado.
2

void allowCoreThreadTimeOut(boolean value)

Establece la política que rige si los subprocesos centrales pueden agotar el tiempo de espera y finalizar si no llegan tareas dentro del tiempo de mantenimiento, y se reemplazan si es necesario cuando llegan nuevas tareas.
3

boolean allowsCoreThreadTimeOut()

Devuelve verdadero si este grupo permite que los subprocesos centrales se agoten y terminen si no llegan tareas dentro del tiempo de keepAlive, y se reemplazan si es necesario cuando llegan nuevas tareas.
4

boolean awaitTermination(long timeout, TimeUnit unit)

Se bloquea hasta que todas las tareas hayan completado la ejecución después de una solicitud de cierre, o se agote el tiempo de espera o se interrumpa el hilo actual, lo que ocurra primero.
5

protected void beforeExecute(Thread t, Runnable r)

Método invocado antes de ejecutar el Runnable dado en el hilo dado.
6

void execute(Runnable command)

Ejecuta la tarea dada en algún momento en el futuro.
7

protected void finalize()

Invoca el cierre cuando ya no se hace referencia a este ejecutor y no tiene hilos.
8

int getActiveCount()

Devuelve el número aproximado de subprocesos que están ejecutando tareas de forma activa.
9

long getCompletedTaskCount()

Devuelve el número total aproximado de tareas que han completado su ejecución.
10

int getCorePoolSize()

Devuelve el número principal de subprocesos.
11

long getKeepAliveTime(TimeUnit unit)

Devuelve el tiempo de mantenimiento de subprocesos, que es la cantidad de tiempo que los subprocesos que superan el tamaño del grupo principal pueden permanecer inactivos antes de finalizar.
12

int getLargestPoolSize()

Devuelve la mayor cantidad de subprocesos que alguna vez han estado simultáneamente en el grupo.
13

int getMaximumPoolSize()

Devuelve el número máximo permitido de subprocesos.
14

int getPoolSize()

Devuelve el número actual de subprocesos en el grupo.
15

BlockingQueue getQueue()

Devuelve la cola de tareas utilizada por este ejecutor.
15

RejectedExecutionHandler getRejectedExecutionHandler()

Devuelve el controlador actual para tareas no ejecutables.
dieciséis

long getTaskCount()

Devuelve el número total aproximado de tareas que se han programado para su ejecución.
17

ThreadFactory getThreadFactory()

Devuelve la fábrica de hilos utilizada para crear nuevos hilos.
18

boolean isShutdown()

Devuelve verdadero si este ejecutor se ha cerrado.
19

boolean isTerminated()

Devuelve verdadero si todas las tareas se completaron después del cierre.
20

boolean isTerminating()

Devuelve verdadero si este ejecutor está en proceso de terminar después de shutdown () o shutdownNow () pero no ha terminado por completo.
21

int prestartAllCoreThreads()

Inicia todos los subprocesos principales, lo que hace que esperen inactivos el trabajo.
22

boolean prestartCoreThread()

Inicia un hilo central, lo que hace que espere inactivo el trabajo.
23

void purge()

Intenta eliminar de la cola de trabajos todas las tareas futuras que se han cancelado.
24

boolean remove(Runnable task)

Elimina esta tarea de la cola interna del ejecutor si está presente, haciendo que no se ejecute si aún no se ha iniciado.
25

void setCorePoolSize(int corePoolSize)

Establece el número principal de subprocesos.
26

void setKeepAliveTime(long time, TimeUnit unit)

Establece el límite de tiempo durante el cual los hilos pueden permanecer inactivos antes de finalizar.
27

void setMaximumPoolSize(int maximumPoolSize)

Establece el número máximo permitido de subprocesos.
28

void setRejectedExecutionHandler(RejectedExecutionHandler handler)

Establece un nuevo controlador para tareas no ejecutables.
29

void setThreadFactory(ThreadFactory threadFactory)

Establece la fábrica de hilos utilizada para crear nuevos hilos.
30

void shutdown()

Inicia un apagado ordenado en el que se ejecutan las tareas enviadas anteriormente, pero no se aceptarán nuevas tareas.
31

List<Runnable> shutdownNow()

Intenta detener todas las tareas en ejecución activa, detiene el procesamiento de las tareas en espera y devuelve una lista de las tareas que estaban en espera de ejecución.
32

protected void terminated()

Método que se invoca cuando el Ejecutor ha terminado.
33

String toString()

Devuelve una cadena que identifica este grupo, así como su estado, incluidas las indicaciones del estado de ejecución y los recuentos estimados de trabajadores y tareas.

Ejemplo

El siguiente programa TestThread muestra el uso de la interfaz ThreadPoolExecutor en un entorno basado en subprocesos.

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

Esto producirá el siguiente resultado.

Salida

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