Exemple de BlockingQueue en Java

Aujourd'hui, nous allons examiner Java BlockingQueue. java.util.concurrent.BlockingQueue est une Queue Java qui prend en charge les opérations qui attendent que la file d'attente devienne non vide lors de la récupération et de la suppression d'un élément, et attendent qu'un espace devienne disponible dans la file d'attente lors de l'ajout d'un élément.

File d'attente bloquante Java

Java BlockingQueue n’accepte pas les valeurs null et lance NullPointerException si vous essayez de stocker une valeur nulle dans la file. Les implémentations de Java BlockingQueue sont thread-safe. Toutes les méthodes de mise en file sont atomiques par nature et utilisent des verrous internes ou d'autres formes de contrôle de la concurrence. L’interface Java BlockingQueue fait partie du framework des collections Java et est principalement utilisée pour implémenter le problème producteur-consommateur. Nous n’avons pas besoin de nous soucier de l’attente de la disponibilité de l’espace pour le producteur ou de l’objet pour le consommateur dans la BlockingQueue car cela est géré par les classes d’implémentation de BlockingQueue. Java fournit plusieurs implémentations de BlockingQueue telles que ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue, etc. Lors de l'implémentation du problème producteur-consommateur avec BlockingQueue, nous utiliserons l'implémentation ArrayBlockingQueue. Voici quelques méthodes importantes que vous devriez connaître.

put(E e) : Cette méthode est utilisée pour insérer des éléments dans la file d'attente. Si la file est pleine, elle attend que de l'espace soit disponible.
E take() : Cette méthode récupère et supprime l'élément en tête de la file d'attente. Si la file est vide, elle attend que l'élément soit disponible.

Implémentons maintenant le problème producteur-consommateur en utilisant la BlockingQueue de Java.

Exemple de BlockingQueue en Java - Message

Juste un objet Java normal qui sera produit par le Producteur et ajouté à la file d'attente. Vous pouvez également l'appeler charge utile ou message de file d'attente.

package com.journaldev.concurrency;

public class Message {
    private String msg;
    
    public Message(String str){
        this.msg=str;
    }

    public String getMsg() {
        return msg;
    }

}

Exemple de BlockingQueue en Java - Producteur

Classe de producteur qui créera des messages et les mettra dans la file d'attente.

package com.journaldev.concurrency;

import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {

    private BlockingQueue<Message> queue;
    
    public Producer(BlockingQueue<Message> q){
        this.queue=q;
    }
    @Override
    public void run() {
        //produce messages
        for(int i=0; i<100; i++){
            Message msg = new Message(""+i);
            try {
                Thread.sleep(i);
                queue.put(msg);
                System.out.println("Produced "+msg.getMsg());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //adding exit message
        Message msg = new Message("exit");
        try {
            queue.put(msg);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

Exemple de BlockingQueue en Java - Consommateur

Classe de consommateur qui traitera les messages de la file d'attente et se terminera lorsque le message de sortie sera reçu.

package com.journaldev.concurrency;

import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable{

private BlockingQueue<Message> queue;
    
    public Consumer(BlockingQueue<Message> q){
        this.queue=q;
    }

    @Override
    public void run() {
        try{
            Message msg;
            //consuming messages until exit message is received
            while((msg = queue.take()).getMsg() !="exit"){
            Thread.sleep(10);
            System.out.println("Consumed "+msg.getMsg());
            }
        }catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Exemple de BlockingQueue Java - Service

Enfin, nous devons créer un service BlockingQueue pour le producteur et le consommateur. Ce service producteur-consommateur créera le BlockingQueue avec une taille fixe et le partagera avec les producteurs et les consommateurs. Ce service démarrera les threads du producteur et du consommateur et se terminera.

package com.journaldev.concurrency;

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

public class ProducerConsumerService {

    public static void main(String[] args) {
        //Creating BlockingQueue of size 10
        BlockingQueue<Message> queue = new ArrayBlockingQueue<>(10);
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);
        //starting producer to produce messages in queue
        new Thread(producer).start();
        //starting consumer to consume messages from queue
        new Thread(consumer).start();
        System.out.println("Producer and Consumer has been started");
    }

}

La sortie du programme exemple Java BlockingQueue ci-dessus est montrée ci-dessous.

Producer and Consumer has been started
Produced 0
Produced 1
Produced 2
Produced 3
Produced 4
Consumed 0
Produced 5
Consumed 1
Produced 6
Produced 7
Consumed 2
Produced 8
...

Le sommeil des threads Java est utilisé dans le producteur et le consommateur pour produire et consommer des messages avec un certain délai.