Java LinkedBlockingQueue

Dans ce tutoriel, nous allons utiliser des exemples pour apprendre la classe LinkedBLockingQueue et ses méthodes.

La classe LinkedBlockingQueue du cadre Collections Java utilise une liste pour fournir une implémentation de file bloquante.

Il implémenteJava BlockingQueue interface.

Création de LinkedBlockingQueue

Pour créer une file bloquante de liste chainée, nous devons importer le paquet java.util.concurrent.LinkedBlockingQueue.

Voici comment nous créons une file bloquante de liste chainée en Java :

1.Sans capacité initiale

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

Dans ce cas, la capacité initiale par défaut est2 ³¹ -1.

2.Avec une capacité initiale

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

Ici,

• Type - Type de la file bloquante de liste chainée

• Capacité - Taille de la file bloquante de liste chainée

Par exemple,

//Créer une taille de5LinkedBlockingQueue de type chaîne de caractères
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
//Créer une taille de5LinkedBlockingQueue de type entier
LinkedBlockingQueue<Integer> age = new LinkedBlockingQueue<>();5);

Attention :Il n'est pas nécessaire de fournir la taille de la liste.

Méthodes LinkedBlockingQueue

La classe LinkedBlockingQueue fournitInterface BlockingQueueToutes les méthodes d'éxecution.

Ces méthodes sont utilisées pour insèrer, accéder et supprimer des éléments de la file bloquante liée.

De plus, nous allons étudier deux méthodes put(), take(), qui supportent les opérations bloquantes dans la file bloquante de liste chainée.

Ces deux méthodes distinguent la file bloquante de liste chainée des files typiques.

Insèrer un élément

• add() - Insère l'élément spécifié dans la file bloquante de liste chainée. Si la file est pleine, léve une exception.

• offer() - Insère l'élément spécifié dans la file bloquante de liste chainée. Si la file est pleine, retourne false.

Par exemple,

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

Résultat de la sortie

LinkedBlockingQueue:　[Dog,　Cat,　Horse]

Accéder à l'élément

• peek() - Retourne un élément de la première place de la file bloquante de liste chainée. Si la file est vide, retourne null.

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

Par exemple,

import java.util.concurrent.LinkedBlockingQueue;
import　java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
　　　　　　　　//Ajouter des éléments
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedBlockingQueue: "　+　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 LinkedBlockingQueue:　");
　　　　　　　　while(iterate.hasNext())　{
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　}
}

Résultat de la sortie

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

Supprimer l'élément

• remove() - Retourner et supprimer l'élément spécifié de la file bloquante liée. Si la file est vide, lancer une exception.

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

• clear() - Supprimer tous les éléments de la file bloquante liée.

Par exemple,

import java.util.concurrent.LinkedBlockingQueue;
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);
　　　　　　　　//　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("LinkedBlockingQueue après mise à jour　"　+　animals);
　　　　}
}

Résultat de la sortie

LinkedBlockingQueue:　[Dog,　Cat,　Horse]
Suppression de l'élément:
Utilisation de　remove():　Dog
Utilisation de　poll():　Cat
LinkedBlockingQueue après mise à jour:　[]

Méthodes put() et take()

Dans le processus multithreadé, nous pouvons utiliser put() et take() pour bloquer une opération de thread afin de le synchroniser avec un autre thread. Ces méthodes attendront jusqu'à ce qu'elles puissent être exécutées avec succès.

Méthode put()

Pour insérer l'élément spécifié à la fin de la file de阻塞链 list, nous utilisons la méthode put().

Si la file de阻塞链 list est pleine, elle attendra jusqu'à ce qu'il y ait suffisamment d'espace pour insérer l'élément.

Par exemple,

import java.util.concurrent.LinkedBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
　　　　　　　try {
　　　　　　　　　　//Ajout d'éléments à animals
　　　　　　　　　　　animals.put("Chien");
　　　　　　　　　　　animals.put("Chat");
　　　　　　　　　　　System.out.println("LinkedBlockingQueue: "　+　animals);
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　System.out.println(e);
　　　　　　　　}
　　　　}
}

Résultat de la sortie

LinkedBlockingQueue: [Chien, Chat]

Ici, si l'opération d'attente est interrompue, la méthode put() peut lever une exception InterruptedException. Par conséquent, nous devons la placer dansDans le bloc try..catch.

Méthode take()

Pour retourner et supprimer un élément de la file de阻塞链表, nous pouvons utiliser la méthode take().

Si la file de阻塞链表 est vide, elle attendra jusqu'à ce qu'il y ait un élément à supprimer dans la file de阻塞链 list.

Par exemple,

import java.util.concurrent.LinkedBlockingQueue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
　　　　　　　try {
　　　　　　　　　　　//Ajout d'éléments à animals
　　　　　　　　　　　animals.put("Chien");
　　　　　　　　　　　animals.put("Chat");
　　　　　　　　　　　System.out.println("LinkedBlockingQueue: "　+　animals);
　　　　　　　　　　　//Suppression d'un élément
　　　　　　　　　　　String element = animals.take();
　　　　　　　　　　　System.out.println("Suppression de l'élément: "　+　element);
　　　　　　　　　　　System.out.println("Nouvelle LinkedBlockingQueue: "　+　animals);
　　　　　　　　}
　　　　　　　　catch(Exception e) {
　　　　　　　　　　　　System.out.println(e);
　　　　　　　　}
　　　　}
}

Résultat de la sortie

LinkedBlockingQueue: [Chien, Chat]
Suppression de l'élément: [Chien]
Nouvelle LinkedBlockingQueue: [Chat]

Ici, si l'opération d'attente est interrompue, la méthode take() lève une exception InterruptedException. Par conséquent, nous devons la placer dans un bloc try...catch.

Other methods

Why use LinkedBlockingQueue?

It is considered to beThread-safeCollection. Therefore, it is usually used in multithreaded 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 linked list blocking queue allows the second thread to wait until the first thread completes its operation.