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

CKTIS / Java

ArrayBlockingQueue(int) : capacité de la file et délai d’inactivité

Créez une file de capacité fixe à deux places et distinguez cette limite d’un délai d’inactivité nul pour les threads excédentaires du pool.

Version : Java SE 21

Syntaxe

public ArrayBlockingQueue(int capacity)

// Java SE 21: a queue with two slots for waiting tasks
new ThreadPoolExecutor(1, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(2))

Dans Java SE 21, ArrayBlockingQueue(int), dans java.util.concurrent, crée une file bloquante vide, adossée à un tableau et de capacité fixe. Avec 2, la file contient au plus deux éléments à la fois ; une capacité nulle ou négative déclenche IllegalArgumentException. Les éléments sont retirés dans l’ordre FIFO, mais la politique par défaut ne garantit pas l’ordre d’accès des threads en attente. Pour leur donner accès dans l’ordre FIFO, utilisez la surcharge ArrayBlockingQueue(int, boolean) avec true.

Si la file est pleine, offer(E) renvoie false sans attendre qu’une place se libère, alors que put(E) attend une place sauf si le thread est interrompu. Comme file de travail d’un ThreadPoolExecutor, sa capacité borne le nombre de tâches qui y attendent, et non le nombre de threads ni le nombre total de tâches acceptées.

Dans le constructeur de ThreadPoolExecutor, 0L est un littéral de type long valant zéro. Le littéral 0 est de type int et convient aussi à ce paramètre grâce à une conversion élargissante vers long. TimeUnit.MILLISECONDS est une constante d’énumération de java.util.concurrent ; une milliseconde vaut un millième de seconde. Un délai de 0L dans cette unité signifie que les threads inactifs au-delà de corePoolSize se terminent sans attendre de nouvelles tâches. Ce n’est pas une limite de durée d’exécution des tâches. Par défaut, les threads du noyau ne sont pas soumis à ce délai ; allowCoreThreadTimeOut(true) exige un délai positif.

Exemples

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        var queue = new ArrayBlockingQueue<String>(2);
        System.out.println(queue.offer("A"));
        System.out.println(queue.offer("B"));
        System.out.println(queue.offer("C"));

        try (var executor = new ThreadPoolExecutor(
                1, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(2))) {
            System.out.println("keepAliveMs=" + executor.getKeepAliveTime(TimeUnit.MILLISECONDS));
        }
    }
}

Résultat

true
true
false
keepAliveMs=0

La file indépendante accepte deux éléments et refuse le troisième (`false`). L’exécuteur dispose de sa propre file à deux places. Le programme lit `keepAliveMs=0` sans exécuter de tâches ni mesurer la durée de vie des threads.

Leçons associées

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

Sources