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

CKTIS / Java

BlockingQueue — une file avec des opérations d’attente

BlockingQueue<E> permet l’échange sûr d’éléments entre threads, par exemple entre un producteur et un consommateur. Elle distingue les opérations qui n’attendent ni place ni élément, celles qui attendent, et les variantes avec délai maximal. L’exemple utilise une ArrayBlockingQueue de capacité 1.

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

Syntaxe

BlockingQueue<E> queue = new ArrayBlockingQueue<>(capacity);
boolean accepted = queue.offer(element);
E removed = queue.poll();
queue.put(element); // throws InterruptedException
E received = queue.take(); // throws InterruptedException
E head = queue.peek();
int count = queue.size();
boolean acceptedInTime = queue.offer(element, timeout, unit);
E receivedInTime = queue.poll(timeout, unit);

BlockingQueue<E>, dans java.util.concurrent, étend Queue<E>. Ses implémentations sont sûres pour les threads et servent notamment à la communication entre producteurs et consommateurs. La capacité et l’ordre dépendent de l’implémentation : ArrayBlockingQueue a une capacité fixe et suit l’ordre FIFO ; l’interface elle-même ne garantit pas FIFO.

BlockingQueue.offer(e) renvoie true après l’ajout, ou false si aucune place n’est disponible. BlockingQueue.poll() retire et renvoie l’élément en tête, ou renvoie null si la file est vide. BlockingQueue.peek() lit l’élément en tête sans le retirer et renvoie null si la file est vide. Ces variantes n’attendent ni une place ni un élément. BlockingQueue.size() renvoie le nombre d’éléments, mais cette valeur peut changer avant l’opération suivante ; ne l’utilisez pas pour vérifier si un ajout ou un retrait ultérieur réussira.

BlockingQueue.put(e) attend qu’une place se libère, tandis que BlockingQueue.take() attend un élément et le retire. Ces opérations peuvent attendre indéfiniment. Les variantes offer(e, timeout, unit) et poll(timeout, unit) limitent l’attente et renvoient respectivement false ou null si le délai expire sans succès. Les opérations d’attente déclarent InterruptedException ; transmettez cette exception ou gérez l’interruption sans l’ignorer silencieusement.

Les éléments ne peuvent pas être null. Chaque opération de mise en file est atomique, mais une suite d’appels ne devient pas atomique pour autant. L’interface ne possède pas d’opération intégrée de fermeture ; la terminaison nécessite un protocole distinct.

L’exemple à un seul thread montre de manière déterministe les états plein et vide. put et take peuvent se terminer immédiatement, car une place libre et un élément disponible sont respectivement présents ; l’exemple ne montre pas d’attente entre threads.

Exemples

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(1);

        System.out.println(queue.offer("A"));
        System.out.println(queue.offer("B"));
        System.out.println(queue.peek());
        System.out.println(queue.size());
        System.out.println(queue.poll());
        System.out.println(queue.poll());

        queue.put("C");
        System.out.println(queue.take());
        System.out.println(queue.size());
    }
}

Résultat

true
false
A
1
A
null
C
0

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