ThreadPoolExecutor Classe

java.util.concurrent.ThreadPoolExecutor è un ExecutorService per eseguire ciascuna attività inoltrata utilizzando uno dei possibili diversi thread in pool, normalmente configurati utilizzando i metodi factory di Executors. Fornisce inoltre vari metodi di utilità per controllare le statistiche dei thread correnti e controllarli.

Metodi ThreadPoolExecutor

Sr.No. Metodo e descrizione
1

protected void afterExecute(Runnable r, Throwable t)

Metodo richiamato al completamento dell'esecuzione del Runnable specificato.
2

void allowCoreThreadTimeOut(boolean value)

Imposta la policy che determina se i thread principali possono scadere e terminare se non arrivano attività entro il tempo keep-alive, sostituendo se necessario quando arrivano nuove attività.
3

boolean allowsCoreThreadTimeOut()

Restituisce vero se questo pool consente ai thread principali di scadere e terminare se non arrivano attività entro il tempo keepAlive, essendo sostituito se necessario quando arrivano nuove attività.
4

boolean awaitTermination(long timeout, TimeUnit unit)

Si blocca fino a quando tutte le attività non hanno completato l'esecuzione dopo una richiesta di arresto, o si verifica il timeout o il thread corrente viene interrotto, a seconda di cosa si verifica per prima.
5

protected void beforeExecute(Thread t, Runnable r)

Metodo richiamato prima di eseguire il Runnable specificato nel thread specificato.
6

void execute(Runnable command)

Esegue l'attività data in futuro.
7

protected void finalize()

Richiama l'arresto quando questo esecutore non è più referenziato e non ha thread.
8

int getActiveCount()

Restituisce il numero approssimativo di thread che stanno attivamente eseguendo attività.
9

long getCompletedTaskCount()

Restituisce il numero totale approssimativo di attività che hanno completato l'esecuzione.
10

int getCorePoolSize()

Restituisce il numero principale di thread.
11

long getKeepAliveTime(TimeUnit unit)

Restituisce il tempo di mantenimento del thread, ovvero la quantità di tempo in cui i thread in eccesso rispetto alla dimensione del pool di base possono rimanere inattivi prima di essere terminati.
12

int getLargestPoolSize()

Restituisce il maggior numero di thread che siano mai stati contemporaneamente nel pool.
13

int getMaximumPoolSize()

Restituisce il numero massimo consentito di thread.
14

int getPoolSize()

Restituisce il numero corrente di thread nel pool.
15

BlockingQueue getQueue()

Restituisce la coda delle attività utilizzata da questo esecutore.
15

RejectedExecutionHandler getRejectedExecutionHandler()

Restituisce il gestore corrente per le attività non eseguibili.
16

long getTaskCount()

Restituisce il numero totale approssimativo di attività che sono state pianificate per l'esecuzione.
17

ThreadFactory getThreadFactory()

Restituisce la thread factory utilizzata per creare nuovi thread.
18

boolean isShutdown()

Restituisce vero se questo esecutore è stato chiuso.
19

boolean isTerminated()

Restituisce vero se tutte le attività sono state completate dopo l'arresto.
20

boolean isTerminating()

Restituisce vero se questo esecutore sta per terminare dopo shutdown () o shutdownNow () ma non è stato completamente terminato.
21

int prestartAllCoreThreads()

Avvia tutti i thread principali, facendoli attendere pigramente il lavoro.
22

boolean prestartCoreThread()

Avvia un thread principale, facendolo aspettare pigramente il lavoro.
23

void purge()

Tenta di rimuovere dalla coda di lavoro tutte le attività future che sono state annullate.
24

boolean remove(Runnable task)

Rimuove questa attività dalla coda interna dell'esecutore, se presente, impedendone l'esecuzione se non è già stata avviata.
25

void setCorePoolSize(int corePoolSize)

Imposta il numero principale di thread.
26

void setKeepAliveTime(long time, TimeUnit unit)

Imposta il limite di tempo per il quale i thread possono rimanere inattivi prima di essere terminati.
27

void setMaximumPoolSize(int maximumPoolSize)

Imposta il numero massimo consentito di thread.
28

void setRejectedExecutionHandler(RejectedExecutionHandler handler)

Imposta un nuovo gestore per le attività non eseguibili.
29

void setThreadFactory(ThreadFactory threadFactory)

Imposta la fabbrica di thread utilizzata per creare nuovi thread.
30

void shutdown()

Avvia un arresto ordinato in cui vengono eseguite le attività inoltrate in precedenza, ma non verranno accettate nuove attività.
31

List<Runnable> shutdownNow()

Tenta di interrompere tutte le attività in esecuzione attiva, interrompe l'elaborazione delle attività in attesa e restituisce un elenco delle attività in attesa di esecuzione.
32

protected void terminated()

Metodo richiamato quando l'Executor è terminato.
33

String toString()

Restituisce una stringa che identifica questo pool, nonché il suo stato, comprese le indicazioni dello stato di esecuzione e dei conteggi stimati di lavoratori e attività.

Esempio

Il seguente programma TestThread mostra l'utilizzo dell'interfaccia ThreadPoolExecutor in un ambiente basato su 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();
         }
      }
   }
}

Questo produrrà il seguente risultato.

Produzione

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