Java ArrayBlockingQueue

File d'attente de blocage de tableau Java

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

Le ArrayBlockingQueue La classe du framework Java Collections fournit l'implémentation de la file d'attente de blocage à l'aide d'un tableau.

Il implémente l'interface Java BlockingQueue.

Création d'ArrayBlockingQueue

Afin de créer une file d'attente de blocage de tableau, nous devons importer le java.util.concurrent.ArrayBlockingQueue paquet.

Une fois le package importé, voici comment créer une file d'attente de blocage de tableau en Java :

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

Ici,

Type - le type de la file d'attente de blocage du tableau
capacité - la taille de la file d'attente de blocage du tableau

Par exemple,

// Creating String type ArrayBlockingQueue with size 5
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

// Creating Integer type ArrayBlockingQueue with size 5
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

Remarque : Il est obligatoire de fournir la taille du tableau.

Méthodes de ArrayBlockingQueue

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

Ces méthodes sont utilisées pour insérer, accéder et supprimer des éléments des files d'attente de blocage de tableaux.

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 du tableau.

Ces deux méthodes distinguent la file d'attente de blocage de tableau des autres files d'attente typiques.

Insérer des éléments

add() - Insère l'élément spécifié dans la file d'attente de blocage du tableau. Il lève une exception si la file d'attente est pleine.
offer() - Insère l'élément spécifié dans la file d'attente de blocage du tableau. Il renvoie false si la file d'attente est pleine.

Par exemple,

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

        // Using add()
        animals.add("Dog");
        animals.add("Cat");

        // Using offer()
        animals.offer("Horse");
        System.out.println("ArrayBlockingQueue: " + animals);
    }
}

Sortie

ArrayBlockingQueue: [Dog, Cat, Horse]

Éléments d'accès

peek() - Renvoie un élément du début de la file d'attente de blocage du tableau. Il renvoie null si la file d'attente est vide.
iterator() - Renvoie un objet itérateur pour accéder séquentiellement aux éléments de la file d'attente de blocage du tableau. Il lève une exception si la file d'attente est vide. Il faut importer le java.util.Iterator package pour 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);

        // Add elements
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayBlockingQueue: " + animals);

        // Using peek()
        String element = animals.peek();
        System.out.println("Accessed Element: " + element);

        // Using iterator()
        Iterator<String> iterate = animals.iterator();
        System.out.print("ArrayBlockingQueue Elements: ");

        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Sortie

ArrayBlockingQueue: [Dog, Cat, Horse]
Accessed Element: Dog
ArrayBlockingQueue Elements: Dog, Cat, Horse,

Supprimer des éléments

remove() - Renvoie et supprime un élément spécifié de la file d'attente de blocage du tableau. 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 du tableau. Il renvoie null si la file d'attente est vide.
clear() - Supprime tous les éléments de la file d'attente de blocage du tableau.

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);

        // 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 ArrayBlockingQueue: " + animals);
    }
}

Sortie

ArrayBlockingQueue: [Dog, Cat, Horse]
Removed Elements:
Using remove(): Dog
Using poll(): Cat
Updated ArrayBlockingQueue: []

Méthode 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 ajouter un élément à la fin d'une file d'attente de blocage de tableau, nous pouvons utiliser le put() méthode.

Si la file d'attente de blocage de tableau est pleine, il attend qu'il y ait de la place dans la file d'attente de blocage de tableau pour ajouter un élément.

Par exemple,

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

       try {
        // Add elements to animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: " + animals);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Sortie

ArrayBlockingQueue: [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 try..catch bloquer.

Méthode take()

Pour renvoyer et supprimer un élément du début de la file d'attente de blocage du tableau, nous pouvons utiliser le take() méthode.

Si la file d'attente de blocage de tableau est vide, il attend qu'il y ait des éléments dans la file d'attente de blocage de tableau à supprimer.

Par exemple,

import java.util.concurrent.ArrayBlockingQueue;

class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);

       try {
           //Add elements to animals
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: " + animals);

           // Remove an element
           String element = animals.take();
           System.out.println("Removed Element: " + element);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Sortie

ArrayBlockingQueue: [Dog, Cat]
Removed Element: Dog

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 dans la file d'attente de blocage du tableau 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 du tableau.
`toArray()`	Convertit la file d'attente de blocage de tableau en tableau et la renvoie.
`toString()`	Convertit la file d'attente de blocage de tableau en chaîne

Pourquoi utiliser ArrayBlockingQueue ?

Le ArrayBlockingQueue utilise des tableaux 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 du tableau peut faire attendre le deuxième thread jusqu'à ce que le premier thread termine ses opérations.

File d'attente de blocage Java Java LinkedBlockingQueue

Java