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

CKTIS / Java

Executors.newFixedThreadPool — pool de threads de taille fixe

Un pool de taille 3 traite au plus trois tâches à la fois, sans qu’elles démarrent nécessairement au même instant. Lorsque tous les threads sont occupés, les tâches supplémentaires attendent dans une file.

Version : Java SE 21

Syntaxe

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

// Static methods declared by Executors:
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)

// Example call:
ExecutorService pool = Executors.newFixedThreadPool(3);

Executors.newFixedThreadPool est une méthode de fabrique statique de la classe java.util.concurrent.Executors. Elle renvoie un ExecutorService qui réutilise ses threads de travail d’une tâche à l’autre. Avec Executors.newFixedThreadPool(3), au plus trois tâches peuvent être en cours à la fois. C’est une limite, pas la garantie qu’elles démarrent au même instant, s’exécutent réellement en parallèle ou se terminent dans l’ordre de soumission.

Lorsque tous les threads de travail sont occupés, les tâches supplémentaires attendent dans une file commune non bornée. La taille du pool limite le nombre de threads, pas le nombre de tâches en attente. Si les tâches arrivent durablement plus vite que le pool ne les termine, la file peut consommer de plus en plus de mémoire. Pour limiter les tâches en attente, utilise un ThreadPoolExecutor avec une file bornée et une politique de rejet choisie explicitement.

La surcharge qui ne prend que int nThreads utilise la fabrique par défaut, qui crée des threads non démons. La surcharge avec ThreadFactory utilise la fabrique fournie pour créer des threads au besoin. Les deux lèvent IllegalArgumentException si nThreads <= 0 ; la seconde lève aussi NullPointerException si la fabrique vaut null. Si un thread s’arrête à la suite d’une défaillance avant la fermeture, le pool le remplace si nécessaire pour exécuter les tâches suivantes.

Ferme le pool dès que tu n’en as plus besoin : les threads créés par défaut peuvent maintenir la JVM en vie. shutdown() n’accepte plus de nouvelles tâches, laisse s’exécuter celles déjà soumises et n’attend pas la fin du pool. En Java SE 21, un try avec ressources appelle close(), qui lance l’arrêt et attend que l’exécuteur se termine.

Exemples

import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FixedPoolDemo {
    public static void main(String[] args)
            throws InterruptedException, ExecutionException {
        CountDownLatch started = new CountDownLatch(3);
        CountDownLatch release = new CountDownLatch(1);

        try (ExecutorService pool = Executors.newFixedThreadPool(3)) {
            Callable<Void> holdWorker = () -> {
                started.countDown();
                release.await();
                return null;
            };

            Future<Integer> fourth;
            try {
                for (int i = 0; i < 3; i++) {
                    pool.submit(holdWorker);
                }
                started.await();
                fourth = pool.submit(() -> 4);
                System.out.println("Fourth task done before release: " + fourth.isDone());
            } finally {
                release.countDown();
            }
            System.out.println("Fourth task result: " + fourth.get());
        }
    }
}

Résultat

Fourth task done before release: false
Fourth task result: 4

Chacune des trois premières tâches occupe un thread et ne peut pas se terminer avant qu’on la libère. `isDone()` renvoie donc `false` pour la quatrième tâche. Après la libération, `get()` attend si nécessaire le résultat `4`. L’exemple montre que les tâches se chevauchent, pas qu’elles démarrent au même instant.

Leçons associées

  • Java · Leçon 50 · Intermédiaire · Version : 2

Sources