Java Language ThreadPoolExecutor


Exemple

Un exécuteur commun utilisé est le ThreadPoolExecutor , qui prend en charge la gestion des threads. Vous pouvez configurer la quantité minimale de threads que l'exécuteur doit toujours maintenir lorsqu'il n'y a pas grand-chose à faire (la taille de base) et une taille de thread maximale à laquelle le pool peut évoluer, s'il reste du travail à faire. Une fois que la charge de travail diminue, le pool réduit à nouveau le nombre de threads jusqu'à ce qu'il atteigne la taille minimale.

ThreadPoolExecutor pool = new ThreadPoolExecutor(
    1,                                     // keep at least one thread ready, 
                                           // even if no Runnables are executed
    5,                                     // at most five Runnables/Threads
                                           // executed in parallel
    1, TimeUnit.MINUTES,                   // idle Threads terminated after one
                                           // minute, when min Pool size exceeded
    new ArrayBlockingQueue<Runnable>(10)); // outstanding Runnables are kept here

pool.execute(new Runnable() {
    @Override public void run() {
        //code to run
    }
});

Remarque Si vous configurez ThreadPoolExecutor avec une file d'attente illimitée , le nombre de threads ne dépassera pas corePoolSize car les nouveaux threads ne sont créés que si la file d'attente est pleine:

ThreadPoolExecutor avec tous les paramètres:

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, 
TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
RejectedExecutionHandler handler)

de JavaDoc

S'il y a plus de corePoolSize mais moins de threads maximumPoolSize, un nouveau thread sera créé uniquement si la file d'attente est pleine.

Avantages:

  1. La taille de BlockingQueue peut être contrôlée et des scénarios de mémoire insuffisante peuvent être évités. Les performances des applications ne seront pas dégradées avec une taille de file d'attente limitée.

  2. Vous pouvez utiliser des stratégies existantes ou créer de nouvelles stratégies de rejet.

    1. Dans le ThreadPoolExecutor.AbortPolicy par défaut, le gestionnaire renvoie une exception RejectedExecutionException à l'exécution lors du rejet.

    2. Dans ThreadPoolExecutor.CallerRunsPolicy , le thread qui appelle exécute lui-même exécute la tâche. Cela fournit un mécanisme de contrôle de rétroaction simple qui ralentira le taux de soumission de nouvelles tâches.

    3. Dans ThreadPoolExecutor.DiscardPolicy , une tâche qui ne peut pas être exécutée est simplement supprimée.

    4. Dans ThreadPoolExecutor.DiscardOldestPolicy , si l'exécuteur n'est pas arrêté, la tâche en tête de la file d'attente de travail est supprimée, puis l'exécution est exécutée à nouveau (ce qui peut échouer à nouveau et entraîner sa répétition).

  3. Custom ThreadFactory peut être configuré, ce qui est utile:

    1. Pour définir un nom de thread plus descriptif
    2. Pour définir le statut du démon de thread
    3. Pour définir la priorité des threads

Voici un exemple d'utilisation de ThreadPoolExecutor