English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Java-Grundlagen-Tutorial

Java Flow Control

Java Array

Java Object-Oriented (I)

Java Object-Oriented (II)

Java Object-Oriented (III)

Java-Exception-Handhabung

Java List (list)

Java Queue (queue)

Java Map collection

Java Set collection

Java Input Output (I/O)

Java Reader/Writer

Java other topics

Java ArrayBlockingQueue

In this tutorial, we will learn about the ArrayBlockingQueue class and its methods with the help of examples.

The ArrayBlockingQueue class of the Java Collections framework provides an implementation of the blocking queue using arrays.

It implementsJava BlockingQueue Schnittstelle.

Create ArrayBlockingQueue

To create an array blocking queue, we must import the java.util.concurrent.ArrayBlockingQueue package.

After importing the package, you can use the following methods to create an array blocking queue in Java:

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

Here,

  • Type - The type of the array blocking queue

  • capacity - The size of the array blocking queue

Zum Beispiel,

//Create a size of5string type ArrayBlockingQueue
ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
//Create a size of5integer type ArrayBlockingQueue
ArrayBlockingQueue<Integer> age = new ArrayBlockingQueue<>(5);

Note:The size of the array must be provided.

ArrayBlockingQueue methods

The ArrayBlockingQueue class provides all the implementations of the methods in the BlockingQueue interface.

These methods are used to insert, access, and delete elements from the array blocking queue.

In addition, we will learn two methods put() and take(), which support blocking operations in the array blocking queue.

These two methods distinguish the array blocking queue from other typical queues.

Insert element

  • add() - Insert the specified element into the array blocking queue. If the queue is full, it will throw an exception.

  • offer() - Insert the specified element into the array blocking queue. If the queue is full, it returns false.

Zum Beispiel,

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

Ausgaberesultat

ArrayBlockingQueue: [Dog, Cat, Horse]

Element aufrufen

  • peek() - Geben Sie ein Element vom Anfang der ArrayBlockingQueue zurück. Wenn die Queue leer ist, wird null zurückgegeben.

  • iterator() - Geben Sie ein Iterator-Objekt zurück, um die Elemente der ArrayBlockingQueue in der Reihenfolge zu durchsuchen. Wenn die Queue leer ist, wird eine Ausnahme ausgelöst. Wir müssen das Softwarepaket java.util.Iterator importieren, um es verwenden zu können.

Zum Beispiel,

import java.util.concurrent.ArrayBlockingQueue;
import java.util.Iterator;
class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
        //Element hinzufügen
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayBlockingQueue: "); + animals);
        // Verwenden Sie	peek()
        String element = animals.peek();
        System.out.println("Element aufrufen: " + element);
        // Verwenden Sie	iterator()
        Iterator<String> iterate = animals.iterator();
        System.out.print("ArrayBlockingQueue-Elemente: ");
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(",	);
        }
    }
}

Ausgaberesultat

ArrayBlockingQueue: [Dog, Cat, Horse]
Element aufrufen: Dog
ArrayBlockingQueue-Elemente: Dog, Cat, Horse,

Element löschen

  • remove() - Geben Sie das angegebene Element zurück und entfernen Sie es aus der ArrayBlockingQueue. Wenn die Queue leer ist, wird eine Ausnahme ausgelöst.

  • poll() - Geben Sie das angegebene Element zurück und entfernen Sie es aus der ArrayBlockingQueue. Wenn die Queue leer ist, wird null zurückgegeben.

  • clear() - Entfernen Sie alle Elemente aus der ArrayBlockingQueue.

Zum Beispiel,

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);
        // Verwenden Sie	remove()
        String element1 = animals.remove();
        System.out.println("Element löschen:");
        System.out.println("Verwenden Sie	remove():	" + element1);
        // Verwenden Sie	poll()
        String element2 = animals.poll();
        System.out.println("Verwenden Sie	poll():	" + element2);
        // Verwenden Sie	clear()
        animals.clear();
        System.out.println("Aktualisierte ArrayBlockingQueue:	" + animals);
    }
}

Ausgaberesultat

ArrayBlockingQueue: [Dog, Cat, Horse]
Element löschen:
Verwenden Sie remove(): Dog
Verwenden Sie poll(): Cat
Aktualisierte ArrayBlockingQueue: []

put() und take() Methoden

In einem Mehr-Prozess-Thread können wir put() und take() verwenden, um die Operation eines Threads zu blockieren und ihn mit einem anderen Thread zu synchronisieren. Diese Methoden warten, bis sie erfolgreich ausgeführt werden können.

put() Methode

Um ein Element an das Ende der ArrayBlockingQueue anzuhängen, kann der put()-Methodenaufruf verwendet werden.

Wenn die ArrayBlockingQueue voll ist, wartet sie, bis genügend Platz in der ArrayBlockingQueue vorhanden ist, um ein Element hinzuzufügen.

Zum Beispiel,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
       try {
           //Elemente zu animals hinzufügen
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: "); + animals);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Ausgaberesultat

ArrayBlockingQueue: [Dog, Cat]

Hier wird eine InterruptedException ausgelöst, wenn der put()-Methodenaufruf unterbrochen wird, während er auf den Abschluss wartet. Daher müssen wir ihn in einem try..catch-Block verpacken.

take() Methode

Um ein Element von der Vorderseite der ArrayBlockingQueue zurückzugeben und zu löschen, können wir den take()-Methodenaufruf verwenden.

Wenn die ArrayBlockingQueue leer ist, wartet sie, bis ein zu löschendes Element in der ArrayBlockingQueue vorhanden ist.

Zum Beispiel,

import java.util.concurrent.ArrayBlockingQueue;
class Main {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> animals = new ArrayBlockingQueue<>(5);
       try {
           //Elemente zu animals hinzufügen
           animals.put("Dog");
           animals.put("Cat");
           System.out.println("ArrayBlockingQueue: "); + animals);
           //Ein Element löschen
           String element = animals.take();
           System.out.println("Gelöschtes Element: "); + element);
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}

Ausgaberesultat

ArrayBlockingQueue: [Dog, Cat]
Gelöschtes Element: Dog

Hier wird eine InterruptedException ausgelöst, wenn der take()-Methodenaufruf unterbrochen wird, während er auf den Abschluss wartet. Daher müssen wir ihn in einem try…catch-Block verpacken.

Andere Methoden

MethodenInhaltsbeschreibung
contains(element)Sucht das angegebene Element in der ArrayBlockingQueue.Gibt true zurück, wenn das Element gefunden wird, sonst false.
size()Gibt die Länge der ArrayBlockingQueue zurück.
toArray()Konvertieren Sie die ArrayBlockingQueue in ein Array und geben Sie es zurück.
toString()Konvertieren Sie die ArrayBlockingQueue in einen String

Warum sollte man ArrayBlockingQueue verwenden?

ArrayBlockingQueue verwendet ein Array als internes Speichermedium.

Es wird alsThread-sicherKollektionen. Daher wird sie häufig in Multithreading-Anwendungen verwendet.

Angenommen, ein Thread fügt Elemente in die Warteschlange ein, während ein anderer Thread Elemente aus der Warteschlange löscht.

Wenn der erste Thread langsamer als der zweite Thread ist, kann die ArrayBlockingQueue den zweiten Thread warten lassen, bis der erste Thread seine Operation abgeschlossen hat.