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

CKTIS / Java

ThreadPoolExecutor : pool borné et CallerRunsPolicy

ThreadPoolExecutor gère un pool de threads et une file de tâches. Découvrez quand il crée des threads ou met les tâches en file, comment ThreadPoolExecutor.CallerRunsPolicy gère la surcharge, et comment shutdown() et awaitTermination() permettent un arrêt ordonné.

Version : Java SE 21; repository runtime, production runtime not attested

Syntaxe

new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new ThreadPoolExecutor.CallerRunsPolicy());
executor.execute(task);
executor.shutdown();
executor.awaitTermination(timeout, unit);

ThreadPoolExecutor exécute les tâches à l’aide de threads regroupés dans un pool. Lorsqu’une tâche est soumise, il crée un thread si le nombre de travailleurs est inférieur à corePoolSize ; sinon, il tente de mettre la tâche en file. Si la file est pleine, il peut créer un thread jusqu’à la limite maximumPoolSize, puis applique la politique de rejet. Une file non bornée empêche généralement le pool de dépasser corePoolSize et peut accumuler un nombre illimité de tâches en attente.

ThreadPoolExecutor.CallerRunsPolicy exécute une tâche rejetée de façon synchrone dans le thread qui appelle execute, sauf si l’executor a été arrêté. Cela ralentit le producteur de tâches, mais peut, par exemple, bloquer un thread qui traite des requêtes. La limite du pool ne tient pas compte de ces exécutions dans le thread appelant. Après l’arrêt, cette politique abandonne la tâche sans signalement, au lieu de lever une exception : son exécution n’est donc pas garantie.

ThreadPoolExecutor.shutdown lance un arrêt ordonné : les tâches déjà acceptées sont exécutées, mais les nouvelles ne sont pas acceptées. Cette méthode n’attend pas la fin des tâches ; utilisez awaitTermination et vérifiez son résultat. shutdownNow() tente seulement d’interrompre les threads ; les tâches doivent donc réagir aux interruptions. Pour provoquer une surcharge, l’exemple utilise un compteur de synchronisation (CountDownLatch) plutôt que des temporisations. Portée : Java SE 21 ; l’environnement d’exécution du dépôt n’est pas attesté, pas plus que celui de production.

Exemples

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch release = new CountDownLatch(1);
        AtomicInteger completed = new AtomicInteger();
        Thread caller = Thread.currentThread();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                1, 1, 0L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(1),
                new ThreadPoolExecutor.CallerRunsPolicy());

        try {
            executor.execute(() -> {
                try {
                    release.await();
                    completed.incrementAndGet();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            executor.execute(() -> completed.incrementAndGet());
            executor.execute(() -> {
                System.out.println("caller thread: "
                        + (Thread.currentThread() == caller));
                completed.incrementAndGet();
            });
        } finally {
            release.countDown();
            executor.shutdown();
        }

        try {
            if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                executor.shutdownNow();
                throw new IllegalStateException("Termination timed out");
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
            throw e;
        }
        System.out.println("completed: " + completed.get());
    }
}

Résultat

caller thread: true
completed: 3

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources