Exemple de BlockingQueue Java

Aujourd’hui, nous allons examiner Java BlockingQueue. java.util.concurrent.BlockingQueue est une file d’attente Java qui prend en charge des opérations qui attendent que la file d’attente ne soit pas vide lors de la récupération et de la suppression d’un élément, et qui attendent que de l’espace soit disponible dans la file d’attente lors de l’ajout d’un élément.

Java BlockingQueue

Java BlockingQueue n’accepte pas les valeurs null et lance une NullPointerException si vous essayez de stocker une valeur nulle dans la file d’attente. Les implémentations de Java BlockingQueue sont thread-safe. Toutes les méthodes d’enfilage sont de nature atomique 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 du producteur-consommateur. Nous n’avons pas besoin de nous inquiéter de l’attente de l’espace disponible pour le producteur ou de l’objet disponible pour le consommateur dans BlockingQueue car cela est géré par les classes d’implémentation de BlockingQueue. Java propose plusieurs implémentations de BlockingQueue telles que ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue, etc. Lors de la mise en œuvre du problème du producteur-consommateur dans 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 d’attente est pleine, elle attend que de l’espace soit disponible.
• E take(): This method retrieves and remove the element from the head of the queue. If queue is empty it waits for the element to be available.

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

Exemple de BlockingQueue Java – Message

Un simple objet Java 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 Java – Producteur

Classe Producteur qui créera des messages et les placera dans la file d’attente.

package com.journaldev.concurrency;

import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {

    private BlockingQueue queue;
    
    public Producer(BlockingQueue q){
        this.queue=q;
    }
    @Override
    public void run() {
        //produire des 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();
            }
        }
        //ajouter un message de sortie
        Message msg = new Message("exit");
        try {
            queue.put(msg);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

Exemple de BlockingQueue Java – Consommateur

Classe Consommateur qui traitera les messages de la file d’attente et se terminera lorsque le message de sortie est reçu.

package com.journaldev.concurrency;

import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable{

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

    @Override
    public void run() {
        try{
            Message msg;
            //consommer des messages jusqu'à ce que le message de sortie soit reçu
            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 la BlockingQueue avec une taille fixe et la partagera à la fois avec les producteurs et les consommateurs. Ce service lancera les threads producteur et consommateur avant de se terminer.

package com.journaldev.concurrency;

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

public class ProducerConsumerService {

    public static void main(String[] args) {
        // Création d'une BlockingQueue de taille 10
        BlockingQueue queue = new ArrayBlockingQueue<>(10);
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);
        // Démarrage du producteur pour produire des messages dans la file d'attente
        new Thread(producer).start();
        // Démarrage du consommateur pour consommer des messages de la file d'attente
        new Thread(consumer).start();
        System.out.println("Producer and Consumer has been started");
    }

}

La sortie du programme d’exemple Java BlockingQueue ci-dessus est affiché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
...

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