Java LinkedBlockingQueue
File d'attente de blocage liée Java
Dans ce tutoriel, nous allons découvrir la classe LinkedBLockingQueue et ses méthodes à l'aide d'exemples.
Le LinkedBlockingQueue classe du Java Collections framework fournit l'implémentation de la file d'attente de blocage à l'aide d'une liste chaînée.
Il implémente l'interface Java BlockingQueue.
Création de LinkedBlockingQueue
Afin de créer une file d'attente de blocage liée, nous devons importer le java.util.concurrent.LinkedBlockingQueue paquet.
Voici comment nous pouvons créer une file d'attente de blocage liée en Java :
LinkedBlockingQueue<Type> animal = new LinkedBlockingQueue<>();
Ici, la capacité initiale par défaut sera 2 31 -1. ®
LinkedBlockingQueue<Type> animal = new LinkedBlockingQueue<>(int capacity);
Ici,
- Type - le type de la file d'attente de blocage liée
- capacité - la taille de la file d'attente de blocage liée
Par exemple,
// Creating String type LinkedBlockingQueue with size 5
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
// Creating Integer type LinkedBlockingQueue with size 5
LinkedBlockingQueue<Integer> age = new LinkedBlockingQueue<>(5);
Remarque : Il n'est pas obligatoire de fournir la taille de la liste chaînée.
Méthodes de LinkedBlockingQueue
Le LinkedBlockingQueue fournit l'implémentation de toutes les méthodes de l'interface BlockingQueue.
Ces méthodes sont utilisées pour insérer, accéder et supprimer des éléments des files d'attente de blocage liées.
Aussi, nous allons découvrir deux méthodes put() et take() qui prennent en charge l'opération de blocage dans la file d'attente de blocage liée.
Ces deux méthodes distinguent la file d'attente de blocage liée des autres files d'attente typiques.
Insérer des éléments
add()- Insère un élément spécifié dans la file d'attente de blocage liée. Il lève une exception si la file d'attente est pleine.offer()- Insère un élément spécifié dans la file d'attente de blocage liée. Il renvoiefalsesi la file d'attente est pleine.
Par exemple,
import java.util.concurrent.LinkedBlockingQueue;
class Main {
public static void main(String[] args) {
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
// Using add()
animals.add("Dog");
animals.add("Cat");
// Using offer()
animals.offer("Horse");
System.out.println("LinkedBlockingQueue: " + animals);
}
}
Sortie
LinkedBlockingQueue: [Dog, Cat, Horse]
Éléments d'accès
peek()- Renvoie un élément du début de la file d'attente de blocage liée. Il renvoienullsi la file d'attente est vide.iterator()- Renvoie un objet itérateur pour accéder séquentiellement à un élément de la file d'attente de blocage liée. Il lève une exception si la file d'attente est vide. Il faut importer lejava.util.Iteratorpackage pour 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);
// Add elements
animals.add("Dog");
animals.add("Cat");
animals.add("Horse");
System.out.println("LinkedBlockingQueue: " + animals);
// Using peek()
String element = animals.peek();
System.out.println("Accessed Element: " + element);
// Using iterator()
Iterator<String> iterate = animals.iterator();
System.out.print("LinkedBlockingQueue Elements: ");
while(iterate.hasNext()) {
System.out.print(iterate.next());
System.out.print(", ");
}
}
}
Sortie
LinkedBlockingQueue: [Dog, Cat, Horse] Accessed Element: Dog LinkedBlockingQueue Elements: Dog, Cat, Horse,
Supprimer des éléments
remove()- Renvoie et supprime un élément spécifié de la file d'attente de blocage liée. Il lève une exception si la file d'attente est vide.poll()- Renvoie et supprime un élément spécifié de la file d'attente de blocage liée. Il renvoienullsi la file d'attente est vide.clear()- Supprime tous les éléments de la file d'attente de blocage 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);
// Using remove()
String element1 = animals.remove();
System.out.println("Removed Element:");
System.out.println("Using remove(): " + element1);
// Using poll()
String element2 = animals.poll();
System.out.println("Using poll(): " + element2);
// Using clear()
animals.clear();
System.out.println("Updated LinkedBlockingQueue " + animals);
}
}
Sortie
LinkedBlockingQueue: [Dog, Cat, Horse] Removed Elements: Using remove(): Dog Using poll(): Cat Updated LinkedBlockingQueue: []
Méthodes put() et take()
Dans les processus multithreading, nous pouvons utiliser put() et take() bloquer le fonctionnement d'un thread pour 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 d'une file d'attente de blocage liée, nous utilisons le put() méthode.
Si la file d'attente de blocage liée est pleine, il attend qu'il y ait de la place dans la file d'attente de blocage liée 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 {
// Add elements to animals
animals.put("Dog");
animals.put("Cat");
System.out.println("LinkedBlockingQueue: " + animals);
}
catch(Exception e) {
System.out.println(e);
}
}
}
Sortie
LinkedBlockingQueue: [Dog, Cat]
Ici, le put() méthode peut lancer un InterruptedException s'il est interrompu pendant l'attente. Par conséquent, nous devons l'enfermer dans un bloc try..catch.
Méthode take()
Pour renvoyer et supprimer un élément du début de la file d'attente de blocage liée, nous pouvons utiliser le take() méthode.
Si la file d'attente de blocage liée est vide, il attend qu'il y ait des éléments dans la file d'attente de blocage liée à supprimer.
Par exemple,
import java.util.concurrent.LinkedBlockingQueue;
class Main {
public static void main(String[] args) {
LinkedBlockingQueue<String> animals = new LinkedBlockingQueue<>(5);
try {
//Add elements to animals
animals.put("Dog");
animals.put("Cat");
System.out.println("LinkedBlockingQueue: " + animals);
// Remove an element
String element = animals.take();
System.out.println("Removed Element: " + element);
System.out.println("New LinkedBlockingQueue: " + animals);
}
catch(Exception e) {
System.out.println(e);
}
}
}
Sortie
LinkedBlockingQueue: [Dog, Cat] Removed Element: Dog New LinkedBlockingQueue: [Cat]
Ici, le take() méthode lancera un InterrupedException s'il est interrompu pendant l'attente. Par conséquent, nous devons l'enfermer dans un try...catch bloquer.
Autres méthodes
| Méthodes | Descriptions |
|---|---|
contains(element) | Recherche la file d'attente de blocage liée pour l'élément spécifié. Si l'élément est trouvé, il renvoie true , sinon il renvoie false . |
size() | Renvoie la longueur de la file d'attente de blocage liée. |
toArray() | Convertit la file d'attente de blocage liée en un tableau et renvoie le tableau. |
toString() | Convertit la file d'attente de blocage liée en chaîne |
Pourquoi utiliser LinkedBlockingQueue ?
Le LinkedBlockingQueue utilise des listes liées comme stockage interne.
Il est considéré comme un thread-safe le recueil. Par conséquent, il est généralement utilisé dans les applications multi-threads.
Supposons qu'un thread insère des éléments dans la file d'attente et qu'un autre thread supprime des éléments de la file d'attente.
Désormais, si le premier thread est plus lent que le deuxième, la file d'attente de blocage liée peut faire attendre le deuxième thread jusqu'à ce que le premier thread termine ses opérations.
Java