Java ArrayBlockingQueue

In deze zelfstudie leren we over de klasse ArrayBlockingQueue en zijn methoden aan de hand van voorbeelden.

De ArrayBlockingQueue klasse van het Java Collections-framework biedt de implementatie van de blokkeringswachtrij met behulp van een array.

Het implementeert de Java BlockingQueue-interface.

ArrayBlockingQueue maken

Om een ​​array-blokkeringswachtrij te maken, moeten we de java.util.concurrent.ArrayBlockingQueue . importeren pakket.

Nadat we het pakket hebben geïmporteerd, kunnen we als volgt een wachtrij voor arrayblokkering in Java maken:

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

Hier,

• Type - het type van de array-blokkerende wachtrij
• capaciteit - de grootte van de wachtrij voor het blokkeren van arrays

Bijvoorbeeld,

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

Opmerking: Het is verplicht om de grootte van de array op te geven.

Methoden van ArrayBlockingQueue

De ArrayBlockingQueue class biedt de implementatie van alle methoden in de BlockingQueue interface.

Deze methoden worden gebruikt om elementen in wachtrijen voor het blokkeren van arrays in te voegen, te openen en te verwijderen.

We zullen ook leren over twee methoden put() en take() die de blokkeerbewerking in de array-blokkeringswachtrij ondersteunen.

Deze twee methoden onderscheiden de array-blokkerende wachtrij van andere typische wachtrijen.

Elementen invoegen

• add() - Voegt het opgegeven element in de array-blokkeringswachtrij in. Het genereert een uitzondering als de wachtrij vol is.
• offer() - Voegt het opgegeven element in de array-blokkeringswachtrij in. Het retourneert false als de wachtrij vol is.

Bijvoorbeeld,

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

Uitvoer

ArrayBlockingQueue: [Dog, Cat, Horse]

Toegangselementen

• peek() - Retourneert een element van de voorkant van de array-blokkerende wachtrij. Het retourneert null als de wachtrij leeg is.
• iterator() - Retourneert een iteratorobject om sequentieel toegang te krijgen tot elementen uit de arrayblokkeringswachtrij. Het genereert een uitzondering als de wachtrij leeg is. We moeten de java.util.Iterator . importeren pakket om het te gebruiken.

Bijvoorbeeld,

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(", ");
        }
    }
}

Uitvoer

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

Elementen verwijderen

• remove() - Retourneert en verwijdert een opgegeven element uit de wachtrij voor arrayblokkering. Het genereert een uitzondering als de wachtrij leeg is.
• poll() - Retourneert en verwijdert een opgegeven element uit de wachtrij voor arrayblokkering. Het retourneert null als de wachtrij leeg is.
• clear() - Verwijdert alle elementen uit de wachtrij voor het blokkeren van arrays.

Bijvoorbeeld,

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

Uitvoer

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

put() en take()-methode

In multithreading-processen kunnen we put() . gebruiken en take() om de werking van een thread te blokkeren om deze te synchroniseren met een andere thread. Deze methoden wachten totdat ze met succes kunnen worden uitgevoerd.

put() methode

Om een ​​element toe te voegen aan het einde van een array-blokkeringswachtrij, kunnen we de put() . gebruiken methode.

Als de array-blokkerende wachtrij vol is, wacht deze totdat er ruimte is in de array-blokkerende wachtrij om een ​​element toe te voegen.

Bijvoorbeeld,

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

Uitvoer

ArrayBlockingQueue: [Dog, Cat]

Hier, de put() methode kan een InterruptedException . genereren als het wordt onderbroken tijdens het wachten. Daarom moeten we het insluiten in een try..catch blok.

take()-methode

Om een ​​element terug te geven en te verwijderen van de voorkant van de array-blokkeringswachtrij, kunnen we de take() gebruiken methode.

Als de array-blokkerende wachtrij leeg is, wacht deze totdat er elementen in de array-blokkerende wachtrij zijn om te worden verwijderd.

Bijvoorbeeld,

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

Uitvoer

ArrayBlockingQueue: [Dog, Cat]
Removed Element: Dog

Hier, de take() methode werpt een InterrupedException als het wordt onderbroken tijdens het wachten. Daarom moeten we het insluiten in een try...catch blok.

Andere methoden

Waarom ArrayBlockingQueue gebruiken?

De ArrayBlockingQueue gebruikt arrays als interne opslag.

Het wordt beschouwd als een thread-safe verzameling. Daarom wordt het over het algemeen gebruikt in toepassingen met meerdere threads.

Stel dat een thread elementen aan de wachtrij toevoegt en een andere thread elementen uit de wachtrij verwijdert.

Als de eerste thread nu langzamer is dan de tweede thread, kan de array-blokkeringswachtrij ervoor zorgen dat de tweede thread wacht totdat de eerste thread zijn bewerkingen voltooit.