Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Pools de threads fixes, capacité de la file et arrêt ordonné

Créez deux pools de deux threads, comparez leurs files d’attente et récupérez les résultats avant d’appeler `shutdown()` sur les deux pools.

Version : Java SE 21

Syntaxe

In java.util.concurrent:
public static ExecutorService Executors.newFixedThreadPool(int nThreads)
public static ExecutorService Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
void ExecutorService.shutdown()
public void ThreadPoolExecutor.shutdown()

Bounded-queue alternative:
new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.AbortPolicy())

Dans Java SE 21, la méthode statique Executors.newFixedThreadPool(2) du paquet java.util.concurrent renvoie un ExecutorService qui réutilise ses threads de travail. Au plus deux threads exécutent des tâches simultanément. Lorsqu’ils sont tous deux occupés, les tâches supplémentaires attendent dans une file commune sans limite de capacité configurée. Limiter le nombre de threads ne limite donc pas le nombre de tâches en attente. Si les tâches arrivent plus vite que le pool ne les termine, la file peut grossir et occuper davantage de mémoire.

La surcharge Executors.newFixedThreadPool(nThreads, threadFactory) utilise la ThreadFactory fournie pour créer les threads, sans limiter la file. Les deux surcharges lèvent IllegalArgumentException si nThreads <= 0 ; la seconde lève NullPointerException si la fabrique vaut null.

Pour limiter les tâches en attente, configurez un ThreadPoolExecutor dont la taille de base et la taille maximale valent 2, avec une ArrayBlockingQueue<>(2). Jusqu’à deux tâches peuvent alors s’exécuter sur les threads du pool et jusqu’à deux autres peuvent attendre dans la file. Si le pool ne peut pas accepter une tâche parce que les deux threads sont occupés et que la file est pleine, AbortPolicy lève RejectedExecutionException au lieu d’attendre qu’une place se libère. Cette politique rejette aussi les soumissions après le début de l’arrêt.

ExecutorService.shutdown() définit le contrat d’arrêt ordonné, et ThreadPoolExecutor.shutdown() le met en œuvre : les tâches déjà acceptées peuvent s’exécuter, les nouvelles sont rejetées et l’appel n’attend pas la fin des tâches. Répéter l’appel n’a pas d’effet supplémentaire. Un gestionnaire de sécurité actif qui refuse l’autorisation peut entraîner une SecurityException. En fonctionnement normal, récupérez tous les résultats nécessaires avec Future.get() avant d’arrêter les deux pools dans finally, qui s’exécute aussi en cas d’échec. get() attend une tâche précise si nécessaire ; pour attendre la fin du pool entier avec un délai maximal après shutdown(), utilisez awaitTermination().

Exemples

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class PoolDemo {
    public static void main(String[] args)
            throws InterruptedException, ExecutionException {
        ExecutorService fixed = Executors.newFixedThreadPool(2);
        ThreadPoolExecutor bounded = new ThreadPoolExecutor(
                2, 2, 0L, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.AbortPolicy());

        try {
            Future<Integer> first = fixed.submit(() -> 2);
            Future<Integer> second = fixed.submit(() -> 3);
            Future<Integer> third = bounded.submit(() -> 5);
            Future<Integer> fourth = bounded.submit(() -> 7);

            int fixedSum = first.get() + second.get();
            int boundedSum = third.get() + fourth.get();
            System.out.println("fixed=" + fixedSum + ", bounded=" + boundedSum);
        } finally {
            try {
                fixed.shutdown();
            } finally {
                bounded.shutdown();
            }
        }
    }
}

Résultat

fixed=5, bounded=12

Le programme soumet deux tâches à chaque pool et récupère les quatre résultats avant l’arrêt en fonctionnement normal. L’ordre d’affichage ne dépend pas de l’ordonnancement des threads. L’exemple ne force ni la saturation de la file ni le rejet d’une tâche.

Leçons associées

  • Java · Leçon 42 · Avancé · Version : 2

Sources