devstory

Le Tutoriel de Java ArrayBlockingQueue

Suivez-nous sur notre fanpage pour recevoir des notifications chaque fois qu'il y a de nouveaux articles. Facebook

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.

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
                          implements BlockingQueue<E>, java.io.Serializable
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.

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