Java ArrayBlockingQueue

Dans ce tutoriel, nous allons apprendre la classe ArrayBlockingQueue et ses méthodes à l'aide d'exemples.

La classe ArrayBlockingQueue du cadre Java Collections fournit une implémentation de file d'attente bloquante d'array utilisant des arrays.

Il implémenteJava BlockingQueue interface.

Créer ArrayBlockingQueue

Pour créer une file d'attente bloquante d'array, nous devons importer le paquet java.util.concurrent.ArrayBlockingQueue.

Après avoir importé le paquet, vous pouvez utiliser les méthodes suivantes pour créer une file d'attente bloquante d'array en Java :

ArrayBlockingQueue<Type> animal = new ArrayBlockingQueue<>(int capacity);

Ici,

• Type - Type de la file d'attente bloquante d'array

• capacity - Taille de la file d'attente bloquante d'array

Par exemple,

//Créer une ArrayBlockingQueue de taille5ArrayBlockingQueue de type chaîne
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>();5);
//Créer une ArrayBlockingQueue de taille5ArrayBlockingQueue de type entier
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

Attention :Il est nécessaire de fournir la taille de l'array.

Méthodes de ArrayBlockingQueue

La classe ArrayBlockingQueue fournit l'implémentation de toutes les méthodes de l'interface BlockingQueue.

De plus, nous allons étudier deux méthodes put() et take(), qui supportent les opérations bloquantes dans la file d'attente bloquante d'array.

Ces deux méthodes distinguent la file d'attente bloquante d'array des files typiques.

Insérer un élément

• add() - Insère l'élément spécifié dans la file d'attente bloquante d'array. Si la file est pleine, elle lève une exception.

• offer() - Insère l'élément spécifié dans la file d'attente bloquante d'array. Si la file est pleine, retourne false.

Par exemple,

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

Résultat de la sortie

ArrayBlockingQueue: [Dog, Cat, Horse]

Accéder à l'élément

• peek() - Retourner un élément du début de la file bloquante d'array. Si la file est vide, retourner null.

• iterator() - Retourner un objet d'itérateur pour accéder en ordre aux éléments de la file bloquante d'array. Si la file est vide, lève une exception. Nous devons importer le paquet java.util.Iterator pour pouvoir l'utiliser.

Par exemple,

import java.util.concurrent.ArrayBlockingQueue;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>();5);
　　　　　　　　//Ajouter des éléments
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　//　Utilisation de peek()
　　　　　　　　String element = animals.peek();
　　　　　　　　System.out.println("Accéder à l'élément: ");　+　element);
　　　　　　　　//　Utilisation de iterator()
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　System.out.print("Éléments de ArrayBlockingQueue: ");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Résultat de la sortie

ArrayBlockingQueue: [Dog, Cat, Horse]
Accéder à l'élément: Dog
Éléments de ArrayBlockingQueue: Dog, Cat, Horse,

Supprimer l'élément

• remove() - Retourner et supprimer l'élément spécifié de la file bloquante d'array. Si la file est vide, lève une exception.

• poll() - Retourner et supprimer l'élément spécifié de la file bloquante d'array. Si la file est vide, retourner null.

• clear() - Supprimer tous les éléments de la file bloquante d'array.

Par exemple,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>();5);
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　//　Utilisation de remove()
　　　　　　　　String element1　= animals.remove();
　　　　　　　　System.out.println("Suppression de l'élément:");
　　　　　　　　System.out.println("Utilisation de remove(): ")　+　element1);
　　　　　　　　//　Utilisation de poll()
　　　　　　　　String element2　= animals.poll();
　　　　　　　　System.out.println("Utilisation de poll(): ")　+　element2);
　　　　　　　　//　Utilisation de clear()
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("Le ArrayBlockingQueue mis à jour: ")　+　animals);
　　　　}
}

Résultat de la sortie

ArrayBlockingQueue: [Dog, Cat, Horse]
Suppression de l'élément:
Utilisation de remove(): Dog
Utilisation de poll(): Cat
ArrayBlockingQueue mis à jour: []

Méthodes put() et take()

Dans un processus multithreadé, nous pouvons utiliser put() et take() pour bloquer l'opération d'un thread, le synchronisant ainsi avec un autre thread. Ces méthodes attendront jusqu'à ce qu'elles puissent exécuter avec succès.

Méthode put()

Pour ajouter un élément à la fin de la file d'attente bloquée par tableau, vous pouvez utiliser la méthode put().

Si la file d'attente bloquée par tableau est pleine, elle attendra jusqu'à ce qu'il y ait suffisamment d'espace dans la file d'attente bloquée par tableau pour ajouter des éléments.

Par exemple,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>();5);
　　　　　　　try {
　　　　　　　　　　　//Ajouter des éléments à animals
　　　　　　　　　　　animals.put("Dog");
　　　　　　　　　　　animals.put("Cat");
　　　　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　System.out.println(e);
　　　　　　　　}
　　　　}
}

Résultat de la sortie

ArrayBlockingQueue: [Dog, Cat]

Ici, si la méthode put() est interrompue pendant l'attente, elle peut lever l'exception InterruptedException. Par conséquent, nous devons la mettre dans un bloc try..catch.

Méthode take()

Pour retourner et supprimer un élément de la file d'attente bloquée par tableau en tête, nous pouvons utiliser la méthode take().

Si la file d'attente bloquée par tableau est vide, elle attendra jusqu'à ce qu'il y ait un élément à supprimer dans la file d'attente bloquée par tableau.

Par exemple,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>();5);
　　　　　　　try {
　　　　　　　　　　　//Ajouter des éléments à animals
　　　　　　　　　　　animals.put("Dog");
　　　　　　　　　　　animals.put("Cat");
　　　　　　　　　　　System.out.println("ArrayBlockingQueue: ");　+　animals);
　　　　　　　　　　　//Supprimer un élément
　　　　　　　　　　　String element = animals.take();
　　　　　　　　　　　System.out.println("Élément supprimé: ");　+　element);
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　System.out.println(e);
　　　　　　　　}
　　　　}
}

Résultat de la sortie

ArrayBlockingQueue: [Dog, Cat]
Élément supprimé: Dog

Ici, si la méthode take() est interrompue pendant l'attente, elle lève l'exception InterruptedException. Par conséquent, nous devons la mettre dans un bloc try...catch.

Other methods

Why use ArrayBlockingQueue?

ArrayBlockingQueue uses an array as its internal storage.

It is considered to beThread-safeCollection. Therefore, it is usually used in multi-threaded applications.

Suppose one thread is inserting elements into the queue, while another thread is deleting elements from the queue.

Now, if the first thread is slower than the second thread, the array blocking queue can make the second thread wait until the first thread completes its operation.