Esempio di BlockingQueue Java

Oggi esamineremo Java BlockingQueue. `java.util.concurrent.BlockingQueue` è una coda Java che supporta operazioni in attesa della coda per diventare non vuota durante il recupero e la rimozione di un elemento, e attende che lo spazio diventi disponibile nella coda durante l’aggiunta di un elemento.

Java BlockingQueue

Java BlockingQueue non accetta valori `null` e genera `NullPointerException` se si cerca di memorizzare un valore nullo nella coda. Le implementazioni di Java BlockingQueue sono thread-safe. Tutti i metodi di accodamento sono atomici per natura e utilizzano blocchi interni o altre forme di controllo di concorrenza. L’interfaccia Java BlockingQueue fa parte del framework delle collezioni Java ed è utilizzata principalmente per implementare il problema del produttore-consumatore. Non è necessario preoccuparsi dell’attesa dello spazio disponibile per il produttore o dell’oggetto disponibile per il consumatore in BlockingQueue poiché è gestito dalle classi di implementazione di BlockingQueue. Java fornisce diverse implementazioni di BlockingQueue come ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue, ecc. Durante l’implementazione del problema del produttore-consumatore in BlockingQueue, utilizzeremo l’implementazione ArrayBlockingQueue. Di seguito sono riportati alcuni importanti metodi che dovresti conoscere.

• put(E e): Questo metodo viene utilizzato per inserire elementi nella coda. Se la coda è piena, attende che lo spazio sia disponibile.
• 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.

Ora implementiamo il problema del produttore-consumatore utilizzando BlockingQueue di Java.

Esempio di BlockingQueue di Java – Messaggio

Solo un normale oggetto Java che verrà prodotto dal Produttore e aggiunto alla coda. Puoi anche chiamarlo payload o messaggio in coda.

package com.journaldev.concurrency;

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

    public String getMsg() {
        return msg;
    }

}

Esempio di BlockingQueue di Java – Produttore

Classe Produttore che creerà messaggi e li inserirà nella coda.

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() {
         // produrre messaggi 
        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();
            }
        }
         // aggiungere messaggio di uscita 
        Message msg = new Message("exit");
        try {
            queue.put(msg);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

Esempio di BlockingQueue di Java – Consumatore

Classe Consumatore che elaborerà i messaggi dalla coda e terminerà quando riceverà il messaggio di uscita.

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;
             // consumare messaggi fino a quando viene ricevuto il messaggio di uscita
            while((msg = queue.take()).getMsg() !="exit"){
            Thread.sleep(10);
            System.out.println("Consumed "+msg.getMsg());
            }
        }catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Esempio di Java BlockingQueue – Servizio

Infine dobbiamo creare un servizio BlockingQueue per produttore e consumatore. Questo servizio produttore consumatore creerà la BlockingQueue con dimensione fissa e la condividerà sia con i produttori che con i consumatori. Questo servizio avvierà i thread produttore e consumatore ed uscirà.

package com.journaldev.concurrency;

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

public class ProducerConsumerService {

    public static void main(String[] args) {
        //Creazione di una BlockingQueue di dimensione 10
        BlockingQueue queue = new ArrayBlockingQueue<>(10);
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);
        //avvio del produttore per produrre messaggi nella coda
        new Thread(producer).start();
        //avvio del consumatore per consumare messaggi dalla coda
        new Thread(consumer).start();
        System.out.println("Producer and Consumer has been started");
    }

}

Di seguito è mostrato l’output del programma di esempio Java BlockingQueue sopra.

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
...

Il sonno del thread Java viene utilizzato nel produttore e nel consumatore per produrre e consumare messaggi con un certo ritardo.