Java LinkedBlockingQueue

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

De LinkedBlockingQueue klasse van de Java Collections framework biedt de implementatie van de blokkeringswachtrij met behulp van een gekoppelde lijst.

Het implementeert de Java BlockingQueue-interface.

LinkedBlockingQueue maken

Om een ​​gekoppelde blokkeerwachtrij te maken, moeten we de java.util.concurrent.LinkedBlockingQueue . importeren pakket.

Hier is hoe we een gekoppelde blokkeerwachtrij in Java kunnen maken:

1. Zonder de initiële capaciteit

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

Hier is de standaard initiële capaciteit 2 ³¹ -1.

2. Met de initiële capaciteit

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

Hier,

• Type - het type van de gekoppelde blokkeerwachtrij
• capaciteit - de grootte van de gekoppelde blokkeerwachtrij

Bijvoorbeeld,

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

Opmerking: Het is niet verplicht om de grootte van de gekoppelde lijst op te geven.

Methoden van LinkedBlockingQueue

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

Deze methoden worden gebruikt om elementen uit gekoppelde blokkeerwachtrijen in te voegen, te openen en te verwijderen.

We zullen ook leren over twee methoden put() en take() die de blokkeerbewerking in de gekoppelde blokkeerwachtrij ondersteunen.

Deze twee methoden onderscheiden de gekoppelde blokkeerwachtrij van andere typische wachtrijen.

Elementen invoegen

• add() - Voegt een gespecificeerd element toe aan de gekoppelde blokkeerwachtrij. Het genereert een uitzondering als de wachtrij vol is.
• offer() - Voegt een gespecificeerd element toe aan de gekoppelde blokkeerwachtrij. Het retourneert false als de wachtrij vol is.

Bijvoorbeeld,

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

Uitvoer

LinkedBlockingQueue: [Dog, Cat, Horse]

Toegangselementen

• peek() - Retourneert een element van de voorkant van de gekoppelde blokkeerwachtrij. Het retourneert null als de wachtrij leeg is.
• iterator() - Retourneert een iteratorobject om sequentieel toegang te krijgen tot een element uit de gekoppelde blokkeerwachtrij. 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.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(", ");
        }
    }
}

Uitvoer

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

Elementen verwijderen

• remove() - Retourneert en verwijdert een opgegeven element uit de gekoppelde blokkeerwachtrij. Het genereert een uitzondering als de wachtrij leeg is.
• poll() - Retourneert en verwijdert een opgegeven element uit de gekoppelde blokkeerwachtrij. Het retourneert null als de wachtrij leeg is.
• clear() - Verwijdert alle elementen uit de gekoppelde blokkeerwachtrij.

Bijvoorbeeld,

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

Uitvoer

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

put() en take() methoden

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 het opgegeven element aan het einde van een gekoppelde blokkeerwachtrij in te voegen, gebruiken we de put() methode.

Als de gekoppelde blokkeerwachtrij vol is, wacht deze totdat er ruimte is in de gekoppelde blokkeerwachtrij om het element in te voegen.

Bijvoorbeeld,

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

Uitvoer

LinkedBlockingQueue: [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 brengen en te verwijderen van de voorkant van de gekoppelde blokkeerwachtrij, kunnen we de take() gebruiken methode.

Als de gekoppelde blokkeerwachtrij leeg is, wacht deze totdat er elementen in de gekoppelde blokkeerwachtrij zijn om te worden verwijderd.

Bijvoorbeeld,

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

Uitvoer

LinkedBlockingQueue: [Dog, Cat]
Removed Element: Dog
New LinkedBlockingQueue: [Cat]

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 LinkedBlockingQueue gebruiken?

De LinkedBlockingQueue gebruikt gekoppelde lijsten 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 gekoppelde blokkeerwachtrij ervoor zorgen dat de tweede thread wacht totdat de eerste thread zijn bewerkingen voltooit.