codestory

Die Anleitung zu Java ArrayBlockingQueue

Folge uns auf unserer fanpage, um jedes Mal benachrichtigt zu werden, wenn es neue Artikel gibt. Facebook

1- ArrayBlockingQueue

ArrayBlockingQueue<E> ist eine Klasse, die die Interface BlockingQueue<E> implementiert, sodass sie über alle Funktionen dieser Interface verfügt. Sehen Sie  den Artikel über BlockingQueue für ein besseres Verständnis mit grundlegenden Beispielen.

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
                          implements BlockingQueue<E>, java.io.Serializable
ArrayBlockingQueue ist eine Warteschlange mit begrenzter Kapazität, die ein internes Array fester Länge zum Speichern der Elemente enthält. Diese Warteschlange sortiert die Elemente nach der Regel FIFO - First In First Out. Die Elemente am Anfang der Warteschlange sind die Elemente, die am längsten in der Warteschlange waren, die Elemente am Ende der Warteschlange sind die neu hinzugefügten Elemente.
Die folgende Abbildung zeigt, wie ArrayBlockingQueue seine Elemente im internen Array speichert.
  • Das Hinzufügen eines neuen Elements zu dieser Warteschlange entspricht dem Zuweisen eines neuen Werts zum Element des Arrays am Index putIndex. Wenn putIndex 0 ist, wird es arrayLength-1 zugewiesen, andernfalls wird es putIndex-1 zugewiesen.
  • Das Entfernen eines Elements aus dieser Warteschlange entspricht der Rückgabe des Elements des Arrays am Index takeIndex. Auch wenn takeIndex 0 ist, wird es arrayLength-1 zugewiesen, andernfalls wird es takeIndex-1 zugewiesen.
ArrayBlockingQueue unterstützt beim Erstellen von Objekten optional Fair Policy. Sobald die faire Richtlinie verwendet wird, respektiert diese Warteschlange die Reihenfolge, in der die Producer- und Consumer-Threads warten. Dies vermeidet das Aushungern eines bestimmten Threads, beispielsweise eines hungernden Consumer-Threads aufgrund einer langen Wartezeit, ohne ein Element aus der Warteschlange zu erhalten.
ArrayBlockingQueue und sein Iterator unterstützen alle optionalen Methoden, die in den Interface Collection und Iterator definiert sind.

2- Constructors

Der Konstruktor der Klasse ArrayBlockingQueue:

public ArrayBlockingQueue(int capacity)  
public ArrayBlockingQueue(int capacity, boolean fair)  
public ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)

3- ArrayBlockingQueue(int)


public ArrayBlockingQueue(int capacity)  
Erstellt ein Objekt ArrayBlockingQueue mit der angegebenen (festen) Kapazität. Die Verwendung dieses Konstruktors entspricht der Verwendung des Konstruktors ArrayBlockingQueue(capacity,false).
Die Richtlinie "fair" wird nicht auf das von diesem Konstruktor erstellte Objekt ArrayBlockingQueue angewendet, dessen Verhalten nicht definiert ist.

4- ArrayBlockingQueue(int, boolean)


public ArrayBlockingQueue(int capacity, boolean fair)  
Erstellt ein Objekt ArrayBlockingQueue mit einer angegebenen (festen) Kapazität und einer angegebenen "fairen" Richtlinie.
fair = true
Auf diese Warteschlange wird eine "faire" Richtlinie angewendet, die die Reihenfolge respektiert, in der die Producer- und Consumer-Threads gemäß den FIFO-Regeln warten, was bedeutet, dass der Thread, der zuerst wartet, zuerst verarbeitet wird.
Die "fair"-Policy hilft, das Verhungern eines bestimmten Threads zu vermeiden, beispielsweise wartet ein Consumer lange, erhält aber keine Elemente aus der Warteschlange.
fair = false
Die "faire" Richtlinie wird nicht angewendet, die Reihenfolge für die Verarbeitung von Threads ist undefiniert

5- ArrayBlockingQueue(int, boolean, Collection)


public ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)
Erstellt ein Objekt ArrayBlockingQueue mit der angegebenen (festen) Kapazität, der angegebenen "fairen" Richtlinie und den bereitgestellten Anfangselementen.
Zum Beispiel:

Collection<String> initialElements = List.of("A", "B", "C");
BlockingQueue<String> queue = new ArrayBlockingQueue<>(10, true, initialElements);

6- Methods

Die Methoden, die von der Interface BockingQueue<E> geerbt werden:

void put(E e) throws InterruptedException;
boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException;
E take() throws InterruptedException;
E poll(long timeout, TimeUnit unit) throws InterruptedException;
int remainingCapacity();
int drainTo(Collection<? super E> c);  
int drainTo(Collection<? super E> c, int maxElements);
Lesen Sie den Artikel über BlockingQueue, um zu erfahren, wie Sie die oben genannten Methoden verwenden.
Methoden, die von der Interface Queue<E> geerbt werden:

boolean add(E e);
boolean offer(E e);
E remove();
E poll();
E element();
E peek();
Die Methoden werden von der Interface Collection<E> geerbt:

int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);  
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
boolean retainAll(Collection<?> c);
void clear();  
boolean equals(Object o);
int hashCode();

default <T> T[] toArray(IntFunction<T[]> generator)  
default boolean removeIf(Predicate<? super E> filter)
default Spliterator<E> spliterator()  
default Stream<E> stream()  
default Stream<E> parallelStream()
  • TODO Link?