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

CKTIS / Java

PriorityBlockingQueue — une file de priorité concurrente

PriorityBlockingQueue est une file de priorité thread-safe et logiquement sans limite. put insère un élément sans attendre de place, tandis que take retire le plus petit élément disponible et attend si la file est vide.

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

Syntaxe

PriorityBlockingQueue<E> queue = new PriorityBlockingQueue<>();
PriorityBlockingQueue<E> ordered = new PriorityBlockingQueue<>(initialCapacity, comparator);
queue.put(element);
E next = queue.take(); // throws InterruptedException

PriorityBlockingQueue<E>, dans java.util.concurrent, implémente BlockingQueue<E>. Contrairement à PriorityQueue, elle est thread-safe. La récupération sélectionne l’élément le plus petit selon l’ordre naturel ou un Comparator fourni au constructeur, et non celui qui a été inséré en premier. Pour des nombres dans l’ordre naturel, les plus petites valeurs sont récupérées en premier.

PriorityBlockingQueue.put(E e) insère un élément sans attendre qu’une place se libère : la file est logiquement sans limite. Le paramètre initialCapacity indique la capacité initiale, et non une limite du nombre d’éléments. Cela ne fournit pas de régulation du flux ; un épuisement de la mémoire peut provoquer OutOfMemoryError.

PriorityBlockingQueue.take() récupère et retire la tête de la file. Si celle-ci est vide, la méthode attend qu’un élément soit disponible. Elle peut lever InterruptedException, qui doit être traitée ou propagée. À l’inverse, poll() renvoie immédiatement null si la file est vide. La priorité s’applique aux éléments actuellement disponibles, et non aux ajouts futurs ni à l’ordre dans lequel les consommateurs terminent leur traitement.

Les éléments null sont interdits ; des éléments incomparables peuvent provoquer ClassCastException. En cas d’égalité, aucun ordre FIFO n’est garanti — utilisez une clé secondaire dans le comparateur si cet ordre est nécessaire. L’itération ne garantit pas l’ordre de priorité. L’exemple insère tous les éléments avant de les récupérer, ce qui rend son résultat déterministe.

Exemples

import java.util.concurrent.PriorityBlockingQueue;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>(2);
        queue.put(30);
        queue.put(10);
        queue.put(20);

        System.out.println(queue.take());
        System.out.println(queue.take());
        System.out.println(queue.take());
        System.out.println(queue.poll());
    }
}

Résultat

10
20
30
null

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