So verwenden Sie Java BlockingQueue

Der Begriff Warteschlange bezieht sich auf Datenstrukturen, in denen das zuerst eingegebene Element zuerst aus der Warteschlange kommt. Das heißt, es folgt dem FIFO-Prinzip. Die Blockierungswarteschlange in Java verfügt über eine Funktion, die den Eintrag des Elements in die Warteschlange blockiert, wenn die Warteschlange voll ist, und darauf wartet, dass die Warteschlange einige Elemente erhält, damit der Löschvorgang erfolgt. Die Blockierungswarteschlange hat sich bei der Lösung der mit Warteschlangen verbundenen Probleme als wirksam erwiesen.

In diesem Artikel zeigen wir detailliert, wie BlockingQueue in Java implementiert wird.

Wie verwende ich Java BlockingQueue?

Die BlockingQueue in Java hilft beim Blockieren der entsprechenden Vorgänge und hilft bei der Lösung von Problemen im Zusammenhang mit den Warteschlangen. Wenn die Warteschlange voll ist, wird der Eintritt der Elemente blockiert. Im zweiten Szenario sollte die Warteschlange beim Entfernen eines Elements nicht null sein. Die Warteschlange muss zu löschende Elemente enthalten.

Die Blockierungswarteschlange kann mithilfe der unten genannten Klassen implementiert werden:

  • ArrayBlockingQueue: Diese Blockierungswarteschlange enthält Elemente im Array.
  • LinkedListBlockingQueue: Diese Blockierungswarteschlange enthält eine verknüpfte Liste zum Ausführen verschiedener Vorgänge.
  • Prioritätsblockierungswarteschlange: Diese Warteschlange verwendet die Prioritätsklasse und implementiert den Blockierungsvorgang für die Warteschlange.

Methode 1: Verwenden von ArrayBlockingQueue()

Das Array BlockingQueue in Java verwendet ein Array von Elementen, um verschiedene Vorgänge wie den Zugriff auf die Elemente sowie das Einfügen und Löschen der Elemente auszuführen. Der setzen() Und entfernen() Die Methode hilft beim Einfügen und Löschen von Elementen aus dem jeweiligen Array.

//import the package for the blockingqueue
import java.util.concurrent.BlockingQueue;
//Import array blocking queue to declare elements in the queue
import java.util.concurrent.ArrayBlockingQueue;
//Create a class for the blocking queue
class blockingqueue {
    public static void main(String[] args) {
        /Enter the capacity of the blocking queue
      BlockingQueue<String> num = new ArrayBlockingQueue<>(8);
      //Use try and catch block
      try {
        num.put("Intro");
        num.put("to");
        num.put("BlockingQueue");
       
        //Print the list of Strings in the blocking queue
        System.out.println("The String in the blocking queue are: " + num);
        // Remove Elements from the blocking queue
        String numberstoberemoved = num.remove();
        System.out.println("The String that has been removed from the queue is : " + numberstoberemoved);
      }
      catch(Exception n) {
          n.getStackTrace();
      }
    }
}

Im obigen Code:

  • Die Pakete für BlockingQueue und ArrayBlockingQueue wurden importiert.
  • Die Elemente wurden mit dem zum Array hinzugefügt setzen() Methode
  • Ein Element im Array wurde mit entfernt entfernen() Methode.
  • Wenn das Array leer ist, wird eine Ausnahme ausgelöst.

Ausgabe

In der obigen Ausgabe wurde die Zeichenfolge „Intro“ mithilfe der Methode aus dem Array entfernt entfernen().

Methode 2: Verwenden von LinkedBlockingQueue()

Die verknüpfte Liste wird verwendet, um den Elementen in der Warteschlange eine blockierende Schnittstelle bereitzustellen. Zwei Methoden: setzen() Und nehmen() werden implementiert, um Elemente hinzuzufügen und das erste Element aus dem Array zu entfernen.

/Import the package the for linked blocking queue
import java.util.concurrent.LinkedBlockingQueue;
//Create a class for the linked blocking queue
class linkedblockingqueue {
    public static void main(String[] args) {
        /Enter the capacity of the blocking queue
      LinkedBlockingQueue<Integer> num = new LinkedBlockingQueue<>(8);
      //Use try and catch block
      try {
        num.put(5);
        num.put(8);
        num.put(9);
        num.put(4);
        num.put(3);
        //Print the list of elements in the blocking queue
        System.out.println("The values in the blocking queue are: " + num);
        // Remove Elements the from blocking queue
        int numberstoberemoved = num.take();
        System.out.println("The number that has been removed from the queue is : " + numberstoberemoved);
      }
      catch(Exception n) {
          n.getStackTrace();
      }
    }
}

Im Code oben:

  • Das Paket für die LinkedBlockingQueue wurde importiert.
  • Die Elemente werden jeweils dem Array hinzugefügt.
  • Der nehmen() Die Methode ist dafür verantwortlich, das Element zu entfernen, das am Kopf der verknüpften Liste vorhanden ist.
  • Die Funktion println() hat die Ergebnisse des entfernten Elements gedruckt.

Ausgabe

In der obigen Ausgabe wurde der Kopf der Warteschlange, der 5 ist, entfernt.

Methode 3: Verwenden von PriorityBlockingQueue()

PriorityBlockingQueue() unterstützt alle Blockierungsregeln. Es ähnelt der Prioritätswarteschlange. Hier sind Codierungsbeispiele, die Ihnen helfen, dieses Konzept besser zu verstehen:

Beispiel 1: PriorityBlockingQueue() für Strings

Im folgenden Code wird zusammen mit den Elementen eine Prioritätsblockierungswarteschlange deklariert. Die Ausgabe druckt die Ergebnisse entsprechend der Priorität.

//Import the Java package for blocking the queue
import java.util.concurrent.PriorityBlockingQueue;
//Create a Class for the functions to be declared.
public class priorityblocking{
public static void main(String[] args)
{
    //Create a String declared in the priority Blocking queue
PriorityBlockingQueue<String> addstr
= new PriorityBlockingQueue<String>();
//Enter Strings
addstr.add("Hello");
addstr.add("to");
addstr.add("Java");
addstr.add("Programming");
// Print queue
System.out.println("The elements in the PriorityBlockingQueue are : \n" + addstr);
}
}

Ausgabe

In der folgenden Ausgabe wurden die Ergebnisse entsprechend der Priorität gedruckt.

Beispiel 2: PriorityBlockingQueue() für Ganzzahlen.

Im folgenden Code werden die Ganzzahlen in der PriorityBlockingQueue deklariert und der Code ist derselbe wie der vorherige.

//Import the Java package for blocking the queue
import java.util.concurrent.PriorityBlockingQueue;

//Create a Class for the functions to be declared.
class priorityblocking {
    public static void main(String[] args) {
        // Create a String declared in the priority Blocking queue
        PriorityBlockingQueue<Integer> addInt = new PriorityBlockingQueue<Integer>();
        // Enter Strings
        addInt.add(10);
        addInt.add(25);
        addInt.add(8);
        addInt.add(3);
        // Print queue
        System.out.println("The elements in the PriorityBlockingQueue are : \n" + addInt);
    }
}

Ausgabe

In der folgenden Ausgabe wurden die ganzzahligen Werte entsprechend der Priorität gedruckt.

Dies fasst die Implementierung von BlockinQueue in Java unter Verwendung verschiedener Klassen zusammen.

Abschluss

Die Java BlockingQueue blockiert den Eintritt des Elements in die Warteschlange, wenn die Warteschlange voll ist. Zum Löschen muss mindestens ein Element vorhanden sein, andernfalls wird die Ausnahme ausgelöst. In diesem Artikel haben wir die Implementierung von Blockingqueue in Java ausführlich besprochen.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen