Java Concurrency - BlockingQueue-Schnittstelle

Eine java.util.concurrent.BlockingQueue-Schnittstelle ist eine Unterschnittstelle der Warteschlangenschnittstelle und unterstützt außerdem Vorgänge wie das Warten, bis die Warteschlange nicht leer ist, bevor ein Element abgerufen wird, und das Warten, bis Speicherplatz in der Warteschlange verfügbar ist, bevor ein Element gespeichert wird .

BlockingQueue-Methoden

Sr.Nr.	Methode & Beschreibung
1	boolean add(E e) Fügt das angegebene Element in diese Warteschlange ein, wenn dies ohne Verletzung der Kapazitätsbeschränkungen sofort möglich ist. Bei Erfolg wird true zurückgegeben und eine IllegalStateException ausgelöst, wenn derzeit kein Speicherplatz verfügbar ist.
2	boolean contains(Object o) Gibt true zurück, wenn diese Warteschlange das angegebene Element enthält.
3	int drainTo(Collection<? super E> c) Entfernt alle verfügbaren Elemente aus dieser Warteschlange und fügt sie der angegebenen Sammlung hinzu.
4	int drainTo(Collection<? super E> c, int maxElements) Entfernt höchstens die angegebene Anzahl verfügbarer Elemente aus dieser Warteschlange und fügt sie der angegebenen Sammlung hinzu.
5	boolean offer(E e) Fügt das angegebene Element in diese Warteschlange ein, wenn dies ohne Verletzung der Kapazitätsbeschränkungen sofort möglich ist, und gibt bei Erfolg true und false zurück, wenn derzeit kein Speicherplatz verfügbar ist.
6	boolean offer(E e, long timeout, TimeUnit unit) Fügt das angegebene Element in diese Warteschlange ein und wartet bei Bedarf bis zur angegebenen Wartezeit, bis Speicherplatz verfügbar ist.
7	E poll(long timeout, TimeUnit unit) Ruft den Kopf dieser Warteschlange ab und entfernt ihn. Warten Sie gegebenenfalls bis zur angegebenen Wartezeit, bis ein Element verfügbar ist.
8	void put(E e) Fügt das angegebene Element in diese Warteschlange ein und wartet bei Bedarf, bis Speicherplatz verfügbar ist.
9	int remainingCapacity() Gibt die Anzahl der zusätzlichen Elemente zurück, die diese Warteschlange idealerweise (ohne Speicher- oder Ressourcenbeschränkungen) ohne Blockierung akzeptieren kann, oder Integer.MAX_VALUE, wenn es keine intrinsische Begrenzung gibt.
10	boolean remove(Object o) Entfernt eine einzelne Instanz des angegebenen Elements aus dieser Warteschlange, falls vorhanden.
11	E take() Ruft den Kopf dieser Warteschlange ab und entfernt ihn. Warten Sie gegebenenfalls, bis ein Element verfügbar ist.

Beispiel

Das folgende TestThread-Programm zeigt die Verwendung der BlockingQueue-Schnittstelle in einer threadbasierten Umgebung.

import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class TestThread {

   public static void main(final String[] arguments) throws InterruptedException {
      BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(10);

      Producer producer = new Producer(queue);
      Consumer consumer = new Consumer(queue);

      new Thread(producer).start();
      new Thread(consumer).start();

      Thread.sleep(4000);
   }  


   static class Producer implements Runnable {
      private BlockingQueue<Integer> queue;

      public Producer(BlockingQueue queue) {
         this.queue = queue;
      }

      @Override
      public void run() {
         Random random = new Random();

         try {
            int result = random.nextInt(100);
            Thread.sleep(1000);
            queue.put(result);
            System.out.println("Added: " + result);
            
            result = random.nextInt(100);
            Thread.sleep(1000);
            queue.put(result);
            System.out.println("Added: " + result);
            
            result = random.nextInt(100);
            Thread.sleep(1000);
            queue.put(result);
            System.out.println("Added: " + result);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }	   
   }

   static class Consumer implements Runnable {
      private BlockingQueue<Integer> queue;

      public Consumer(BlockingQueue queue) {
         this.queue = queue;
      }
      
      @Override
      public void run() {
         
         try {
            System.out.println("Removed: " + queue.take());
            System.out.println("Removed: " + queue.take());
            System.out.println("Removed: " + queue.take());
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      }
   }
}

Dies führt zu folgendem Ergebnis.

Ausgabe

Added: 52
Removed: 52
Added: 70
Removed: 70
Added: 27
Removed: 27