Le Tutoriel de Java ArrayBlockingQueue

ArrayBlockingQueue
Constructors
ArrayBlockingQueue(int)
ArrayBlockingQueue(int, boolean)
ArrayBlockingQueue(int, boolean, Collection)
Methods

1. ArrayBlockingQueue

ArrayBlockingQueue<E> est une classe qui implémente l'interface BlockingQueue<E>, elle dispose donc de toutes les fonctionnalités de cette interface. Voir l'article sur BlockingQueue pour mieux comprendre à travers des exemples de base.

Le Tutoriel de Java BlockingQueue

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
                          implements BlockingQueue<E>, java.io.Serializable

Collection
BlockingQueue
Queue

ArrayBlockingQueue est une file d'attente à capacité limitée, qui contient un tableau interne de longueur fixe pour stocker les éléments. Cette file d'attente trie les éléments selon la règle FIFO - First In First Out. Les éléments en tête de file d'attente sont les éléments qui ont été dans la file d'attente le plus longtemps, les éléments en queue de file d'attente sont les éléments nouvellement ajoutés.

La figure ci-dessous démontre comment ArrayBlockingQueue stocke ses éléments dans le tableau interne.

L'ajout d'un nouvel élément à cette file d'attente correspond à l'attribution d'une nouvelle valeur à l'élément du tableau à l'index putIndex. De plus, si putIndex vaut 0, il sera affecté à arrayLength-1, sinon il sera affecté à putIndex-1.
Prendre un élément de cette file d'attente correspond au retour de l'élément du tableau à l'index takeIndex. De plus, si takeIndex vaut 0, il sera affecté à arrayLength-1, sinon il sera affecté à takeIndex-1.

ArrayBlockingQueue prend en charge la politique équitable en option au cours de la création d'objets. Lorsque la politique équitable est utilisée, cette file d'attente respectera l'ordre dans lequel les threads Producer et Consumer attendent. Cela évite la famine d'un certain thread, comme un thread consommateur affamé en raison d'un long temps d'attente sans recevoir aucun élément de la file d'attente.

ArrayBlockingQueue et son Iterator prennent en charge toutes les méthodes facultatives définies dans les interfaces Collection et Iterator.

Iterator
Collection

2. Constructors

Les constructeurs de la classe 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)

Créer un objet ArrayBlockingQueue avec la capacité (fixe) spécifiée. L'utilisation de ce constructeur équivaut à l'utilisation du constructeur ArrayBlockingQueue(capacity,false).

La politique "équitable" n'est pas appliquée à l'objet ArrayBlockingQueue créé par ce constructeur, dont le comportement est indéfini.

4. ArrayBlockingQueue(int, boolean)

public ArrayBlockingQueue(int capacity, boolean fair)

Créer un objet ArrayBlockingQueue avec une capacité (fixe) spécifiée, avec une stratégie "équitable" spécifiée.

fair = true

Une politique "équitable" sera appliquée à cette file d'attente, qui respecte l'ordre dans lequel les threads Producer et Consumer attendent selon les règles FIFO, ce qui signifie que le thread qui attend en premier sera traité en premier.

La politique «équitable» permet d'éviter la famine d'un certain thread, par exemple, un Consumer attend longtemps mais ne reçoit aucun élément de la file d'attente.

fair = false

La politique "équitable" n'est pas appliquée, l'ordre de traitement des threads n'est pas défini

5. ArrayBlockingQueue(int, boolean, Collection)

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

Créer un objet ArrayBlockingQueue avec la capacité (fixe) spécifiée, la stratégie "équitable" spécifiée et les éléments initiaux fournis.

Par exemple :

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

6. Methods

Les méthodes héritées de l'interface BockingQueue<E> :

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

Voir l'article BlockingQueue pour apprendre à utiliser les méthodes ci-dessus.

Le Tutoriel de Java BlockingQueue

Les méthodes héritées de l'interface Queue<E> :

boolean add(E e);
boolean offer(E e);
E remove();
E poll();
E element();
E peek();

Le Tutoriel de Java Queue

Les méthodes sont héritées de l'interface Collection<E> :

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()

Java Collection
Le Tutoriel de Java Iterator