Java ArrayBlockingQueue : Guide Avancé sur les Files de Blocage et Opérations Thread-Safe

Java ArrayBlockingQueue

Explorez la classe Java ArrayBlockingQueue – apprenez à créer, manipuler et utiliser de manière thread-safe cette file de blocage à taille fixe avec des exemples clairs.

La classe ArrayBlockingQueue du framework Java Collections fournit une file thread-safe, bornée, appuyée par un tableau. Elle implémente l'interface BlockingQueue, permettant aux producteurs et consommateurs de se coordonner via des opérations de blocage.

---

Création d'un ArrayBlockingQueue

Importez java.util.concurrent.ArrayBlockingQueue et instanciez avec une capacité fixe :

ArrayBlockingQueue<Type> queue = new ArrayBlockingQueue<>(capacity);

Où Type est le type d'élément et capacity est la taille maximale.

• Exemple – File de chaînes de taille 5 :

  ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

• Exemple – File d'entiers de taille 5 :

  ArrayBlockingQueue<Integer> ages = new ArrayBlockingQueue<>(5);

Note : La capacité est obligatoire ; elle détermine la taille bornée de la file.

---

Méthodes Principales d'ArrayBlockingQueue

La classe implémente toutes les méthodes de BlockingQueue pour l'insertion, l'accès et la suppression d'éléments. Voici les opérations les plus fréquemment utilisées.

Insérer des Éléments

• add(E e) – Ajoute l'élément ; lève IllegalStateException si pleine.
• offer(E e) – Ajoute l'élément ; retourne false si pleine.

ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
animals.add("Dog");
animals.offer("Cat");
animals.offer("Horse");
System.out.println("ArrayBlockingQueue: " + animals);

Sortie : ArrayBlockingQueue: [Dog, Cat, Horse]

Accéder aux Éléments

• peek() – Récupère la tête sans suppression ; retourne null si vide.
• iterator() – Fournit un itérateur fail-fast sur la file.

String head = animals.peek();
System.out.println("Élément tête: " + head);
Iterator<String> it = animals.iterator();
while (it.hasNext()) {
    System.out.print(it.next() + ", ");
}

Sortie : Élément tête: Dog suivi de la liste des éléments.

Supprimer des Éléments

• remove() – Supprime et retourne la tête ; lève NoSuchElementException si vide.
• poll() – Supprime et retourne la tête ; retourne null si vide.
• clear() – Vide la file.

String removed1 = animals.remove();
String removed2 = animals.poll();
animals.clear();
System.out.println("File mise à jour: " + animals);

Sortie : File mise à jour: []

---

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

Ces méthodes sont essentielles pour les patterns producteur-consommateur. Elles bloquent jusqu'à ce que l'opération puisse être effectuée, assurant la coordination des threads.

put()

Insère un élément, en attendant si la file est pleine. Peut lever InterruptedException.

try {
    animals.put("Dog");
    animals.put("Cat");
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

take()

Supprime et retourne la tête, en attendant si la file est vide. Peut lever InterruptedException.

try {
    String element = animals.take();
    System.out.println("Supprimé: " + element);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

---

Méthodes Utilitaires Supplémentaires

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

---

Pourquoi Utiliser ArrayBlockingQueue?

Parce qu'elle offre :

• Sécurité des threads : Synchronisation intégrée pour l'accès concurrent.
• Taille fixe : Empêche la croissance incontrôlée de la mémoire.
• Sémantique de blocage : Simplifie la coordination producteur-consommateur.

Quand un thread produit plus lentement que le consommateur, ce dernier bloque automatiquement, évitant le busy-waiting et assurant une utilisation efficace du CPU.