Classe ThreadPoolExecutor

java.util.concurrent.ThreadPoolExecutor est un ExecutorService pour exécuter chaque tâche soumise en utilisant l'un des éventuellement plusieurs threads regroupés, normalement configurés à l'aide des méthodes d'usine Executors. Il fournit également diverses méthodes utilitaires pour vérifier les statistiques des threads actuels et les contrôler.

Méthodes ThreadPoolExecutor

N ° Sr. Méthode et description
1

protected void afterExecute(Runnable r, Throwable t)

Méthode appelée à la fin de l'exécution du Runnable donné.
2

void allowCoreThreadTimeOut(boolean value)

Définit la stratégie régissant si les threads principaux peuvent expirer et se terminer si aucune tâche n'arrive dans le délai de conservation, remplacés si nécessaire lorsque de nouvelles tâches arrivent.
3

boolean allowsCoreThreadTimeOut()

Renvoie true si ce pool permet aux threads principaux d'expirer et de se terminer si aucune tâche n'arrive dans le délai de keepAlive, remplacé si nécessaire lorsque de nouvelles tâches arrivent.
4

boolean awaitTermination(long timeout, TimeUnit unit)

Bloque jusqu'à ce que toutes les tâches aient terminé l'exécution après une demande d'arrêt, ou que le délai d'expiration se produise ou que le thread en cours soit interrompu, selon la première éventualité.
5

protected void beforeExecute(Thread t, Runnable r)

Méthode appelée avant d'exécuter le Runnable donné dans le thread donné.
6

void execute(Runnable command)

Exécute la tâche donnée ultérieurement.
sept

protected void finalize()

Appelle l'arrêt lorsque cet exécuteur n'est plus référencé et qu'il n'a pas de threads.
8

int getActiveCount()

Renvoie le nombre approximatif de threads qui exécutent activement des tâches.
9

long getCompletedTaskCount()

Renvoie le nombre total approximatif de tâches dont l'exécution est terminée.
dix

int getCorePoolSize()

Renvoie le nombre principal de threads.
11

long getKeepAliveTime(TimeUnit unit)

Renvoie la durée de conservation des threads, qui correspond à la durée pendant laquelle les threads dépassant la taille du pool de cœurs peuvent rester inactifs avant d'être arrêtés.
12

int getLargestPoolSize()

Renvoie le plus grand nombre de threads qui ont jamais été simultanément dans le pool.
13

int getMaximumPoolSize()

Renvoie le nombre maximal de threads autorisé.
14

int getPoolSize()

Renvoie le nombre actuel de threads dans le pool.
15

BlockingQueue getQueue()

Renvoie la file d'attente des tâches utilisée par cet exécuteur.
15

RejectedExecutionHandler getRejectedExecutionHandler()

Renvoie le gestionnaire actuel pour les tâches non exécutables.
16

long getTaskCount()

Renvoie le nombre total approximatif de tâches dont l'exécution a déjà été planifiée.
17

ThreadFactory getThreadFactory()

Renvoie la fabrique de threads utilisée pour créer de nouveaux threads.
18

boolean isShutdown()

Renvoie true si cet exécuteur a été arrêté.
19

boolean isTerminated()

Renvoie true si toutes les tâches sont terminées après l'arrêt.
20

boolean isTerminating()

Renvoie true si cet exécuteur est en train de se terminer après shutdown () ou shutdownNow () mais ne s'est pas complètement arrêté.
21

int prestartAllCoreThreads()

Démarre tous les threads principaux, les obligeant à attendre inutilement le travail.
22

boolean prestartCoreThread()

Démarre un thread principal, le faisant attendre inutilement le travail.
23

void purge()

Tente de supprimer de la file d'attente de travail toutes les tâches futures qui ont été annulées.
24

boolean remove(Runnable task)

Supprime cette tâche de la file d'attente interne de l'exécuteur si elle est présente, empêchant ainsi son exécution si elle n'a pas déjà démarré.
25

void setCorePoolSize(int corePoolSize)

Définit le nombre principal de threads.
26

void setKeepAliveTime(long time, TimeUnit unit)

Définit la durée pendant laquelle les threads peuvent rester inactifs avant d'être arrêtés.
27

void setMaximumPoolSize(int maximumPoolSize)

Définit le nombre maximum autorisé de threads.
28

void setRejectedExecutionHandler(RejectedExecutionHandler handler)

Définit un nouveau gestionnaire pour les tâches non exécutables.
29

void setThreadFactory(ThreadFactory threadFactory)

Définit la fabrique de threads utilisée pour créer de nouveaux threads.
30

void shutdown()

Lance un arrêt ordonné dans lequel les tâches précédemment soumises sont exécutées, mais aucune nouvelle tâche ne sera acceptée.
31

List<Runnable> shutdownNow()

Tente d'arrêter toutes les tâches en cours d'exécution, interrompt le traitement des tâches en attente et renvoie une liste des tâches en attente d'exécution.
32

protected void terminated()

Méthode appelée lorsque l'exécuteur s'est arrêté.
33

String toString()

Renvoie une chaîne identifiant ce pool, ainsi que son état, y compris des indications sur l'état d'exécution et le nombre estimé de travailleurs et de tâches.

Exemple

Le programme TestThread suivant montre l'utilisation de l'interface ThreadPoolExecutor dans un environnement basé sur les threads.

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

Cela produira le résultat suivant.

Production

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