Concurrence Java - Interface BlockingQueue

Une interface java.util.concurrent.BlockingQueue est une sous-interface de l'interface de file d'attente et prend en charge en outre des opérations telles que l'attente que la file d'attente devienne non vide avant de récupérer un élément, et attendre que de l'espace devienne disponible dans la file d'attente avant de stocker un élément .

Méthodes BlockingQueue

N ° Sr.	Méthode et description
1	boolean add(E e) Insère l'élément spécifié dans cette file d'attente s'il est possible de le faire immédiatement sans violer les restrictions de capacité, en retournant true en cas de succès et en lançant une IllegalStateException si aucun espace n'est actuellement disponible.
2	boolean contains(Object o) Renvoie true si cette file d'attente contient l'élément spécifié.
3	int drainTo(Collection<? super E> c) Supprime tous les éléments disponibles de cette file d'attente et les ajoute à la collection donnée.
4	int drainTo(Collection<? super E> c, int maxElements) Supprime au maximum le nombre donné d'éléments disponibles de cette file d'attente et les ajoute à la collection donnée.
5	boolean offer(E e) Insère l'élément spécifié dans cette file d'attente s'il est possible de le faire immédiatement sans violer les restrictions de capacité, renvoyant true en cas de succès et false si aucun espace n'est actuellement disponible.
6	boolean offer(E e, long timeout, TimeUnit unit) Insère l'élément spécifié dans cette file d'attente, en attendant le temps d'attente spécifié si nécessaire pour que l'espace devienne disponible.
sept	E poll(long timeout, TimeUnit unit) Récupère et supprime la tête de cette file d'attente, en attendant le temps d'attente spécifié si nécessaire pour qu'un élément devienne disponible.
8	void put(E e) Insère l'élément spécifié dans cette file d'attente, en attendant si nécessaire que de l'espace devienne disponible.
9	int remainingCapacity() Renvoie le nombre d'éléments supplémentaires que cette file d'attente peut idéalement (en l'absence de contraintes de mémoire ou de ressources) accepter sans blocage, ou Integer.MAX_VALUE s'il n'y a pas de limite intrinsèque.
dix	boolean remove(Object o) Supprime une seule instance de l'élément spécifié de cette file d'attente, si elle est présente.
11	E take() Récupère et supprime la tête de cette file d'attente, en attendant si nécessaire qu'un élément devienne disponible.

Exemple

Le programme TestThread suivant montre l'utilisation de l'interface BlockingQueue dans un environnement basé sur les threads.

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

Cela produira le résultat suivant.

Production

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