Maîtriser Java LinkedBlockingQueue : Guide Complet et Exemples

Java LinkedBlockingQueue

Explorez la classe LinkedBlockingQueue, ses méthodes principales et des exemples réels pour débloquer la file thread-safe en Java.

La classe LinkedBlockingQueue, partie du package java.util.concurrent de Java, implémente une file de blocage appuyée par une liste chaînée. Elle conforme à l'interface BlockingQueue, fournissant une structure robuste et thread-safe pour les scénarios producteur-consommateur concurrents.

---

Création d'un LinkedBlockingQueue

Pour utiliser cette file, importez java.util.concurrent.LinkedBlockingQueue :

import java.util.concurrent.LinkedBlockingQueue;

1. Sans Capacité Initiale

LinkedBlockingQueue<Type> queue = new LinkedBlockingQueue<>();

La capacité par défaut est Integer.MAX_VALUE (2³¹–1), rendant la file effectivement non-bornée.

2. Avec une Capacité Spécifiée

LinkedBlockingQueue<Type> queue = new LinkedBlockingQueue<>(int capacity);

• Type – le type d'élément (ex: String, Integer)
• capacity – nombre maximal d'éléments que la file peut contenir

Exemple :

// File de chaînes avec capacité 5
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
// File d'entiers avec capacité 5
LinkedBlockingQueue<Integer> ages = new LinkedBlockingQueue<>(5);

Note : La capacité est optionnelle ; l'omettre crée une file non-bornée.

---

Méthodes Clés de LinkedBlockingQueue

La classe implémente toutes les méthodes de BlockingQueue, permettant l'insertion, la récupération et la suppression d'éléments. Deux méthodes – put() et take() – fournissent le comportement de blocage qui distingue cette file des files standards.

Insérer des Éléments

• add(E e) – Ajoute un élément, levant une exception si la file est pleine.
• offer(E e) – Ajoute un élément, retournant false si la file est pleine.

Exemple :

import java.util.concurrent.LinkedBlockingQueue;
public class Main {
    public static void main(String[] args) {
        LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
        animals.add("Dog");
        animals.add("Cat");
        animals.offer("Horse");
        System.out.println("LinkedBlockingQueue: " + animals);
    }
}

Sortie

LinkedBlockingQueue: [Dog, Cat, Horse]

Accéder aux Éléments

• peek() – Récupère sans supprimer l'élément de tête ; retourne null si vide.
• iterator() – Fournit un itérateur fail-safe sur la file. Importez java.util.Iterator pour l'utiliser.

Exemple :

import java.util.concurrent.LinkedBlockingQueue;
import java.util.Iterator;
public class Main {
    public static void main(String[] args) {
        LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("LinkedBlockingQueue: " + animals);
        String head = animals.peek();
        System.out.println("Élément Accédé: " + head);
        Iterator<String> it = animals.iterator();
        System.out.print("Éléments LinkedBlockingQueue: ");
        while (it.hasNext()) {
            System.out.print(it.next() + ", ");
        }
    }
}

Sortie

LinkedBlockingQueue: [Dog, Cat, Horse] Élément Accédé: Dog Éléments LinkedBlockingQueue: Dog, Cat, Horse, 

Supprimer des Éléments

• remove() – Supprime et retourne la tête ; lève une exception si vide.
• poll() – Supprime et retourne la tête ; retourne null si vide.
• clear() – Élimine tous les éléments.

Exemple :

import java.util.concurrent.LinkedBlockingQueue;
public class Main {
    public static void main(String[] args) {
        LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("LinkedBlockingQueue: " + animals);
        String removed = animals.remove();
        System.out.println("Avec remove(): " + removed);
        String polled = animals.poll();
        System.out.println("Avec poll(): " + polled);
        animals.clear();
        System.out.println("LinkedBlockingQueue Mis à Jour: " + animals);
    }
}

Sortie

LinkedBlockingQueue: [Dog, Cat, Horse] Avec remove(): Dog Avec poll(): Cat LinkedBlockingQueue Mis à Jour: []

---

Opérations de Blocage : put() et take()

Dans les contextes concurrents, put() et take() bloquent le thread appelant jusqu'à ce que l'opération puisse se poursuivre, assurant une coordination sûre entre producteurs et consommateurs.

put()

Insère un élément à la fin, en attendant si la file est pleine.

Exemple :

import java.util.concurrent.LinkedBlockingQueue;
public class Main {
    public static void main(String[] args) {
        LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
        try {
            animals.put("Dog");
            animals.put("Cat");
            System.out.println("LinkedBlockingQueue: " + animals);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println(e.getMessage());
        }
    }
}

Sortie

LinkedBlockingQueue: [Dog, Cat]

take()

Récupère et supprime l'élément de tête, bloquant si la file est vide.

Exemple :

import java.util.concurrent.LinkedBlockingQueue;
public class Main {
    public static void main(String[] args) {
        LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
        try {
            animals.put("Dog");
            animals.put("Cat");
            System.out.println("LinkedBlockingQueue: " + animals);
            String removed = animals.take();
            System.out.println("Élément Supprimé: " + removed);
            System.out.println("Nouveau LinkedBlockingQueue: " + animals);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println(e.getMessage());
        }
    }
}

Sortie

LinkedBlockingQueue: [Dog, Cat] Élément Supprimé: Dog Nouveau LinkedBlockingQueue: [Cat]

---

Méthodes Utilitaires Supplémentaires

Méthode	Description
contains(Object o)	Vérifie si la file contient l'élément spécifié.
size()	Retourne le nombre actuel d'éléments.
toArray()	Convertit la file en tableau.
toString()	Fournit une représentation en chaîne de la file.

---

Pourquoi Choisir LinkedBlockingQueue?

Parce qu'elle utilise une liste chaînée en interne, LinkedBlockingQueue offre :

• Thread-safety out of the box.
• Capacité bornée optionnelle pour le contrôle de back-pressure.
• Méthodes de blocage qui coordonnent naturellement producteurs et consommateurs.

Dans les applications multithread où un thread peut produire plus lentement qu'un autre ne consomme, la file suspendra automatiquement le consommateur jusqu'à l'arrivée de nouveaux éléments, prévenant le busy-waiting et réduisant la surcharge CPU.

Pour les charges de travail concurrentes haute performance, l'API de concurrence Java recommande LinkedBlockingQueue comme structure de choix pour les pipelines producteur-consommateur.