Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

BlockingQueue — una coda con operazioni in attesa

BlockingQueue<E> consente di scambiare elementi tra thread in modo sicuro, ad esempio tra un produttore e un consumatore. Distingue le operazioni che non attendono spazio o elementi, quelle in attesa e le varianti con limite di tempo. L’esempio usa una ArrayBlockingQueue con capacità 1.

Versione: Java SE 21; repository runtime, production runtime not attested

Sintassi

BlockingQueue<E> queue = new ArrayBlockingQueue<>(capacity);
boolean accepted = queue.offer(element);
E removed = queue.poll();
queue.put(element); // throws InterruptedException
E received = queue.take(); // throws InterruptedException
E head = queue.peek();
int count = queue.size();
boolean acceptedInTime = queue.offer(element, timeout, unit);
E receivedInTime = queue.poll(timeout, unit);

BlockingQueue<E> del pacchetto java.util.concurrent estende Queue<E>. Le sue implementazioni sono thread-safe e supportano, tra gli altri usi, la comunicazione produttore-consumatore. Capacità e ordine dipendono dall’implementazione: ArrayBlockingQueue ha capacità fissa e ordine FIFO; l’interfaccia in sé non garantisce FIFO.

BlockingQueue.offer(e) restituisce true dopo l’inserimento oppure false se non c’è spazio. BlockingQueue.poll() rimuove e restituisce l’elemento in testa, oppure restituisce null se la coda è vuota. BlockingQueue.peek() legge l’elemento in testa senza rimuoverlo e restituisce null se la coda è vuota. Queste varianti non attendono né spazio né elementi. BlockingQueue.size() restituisce il numero di elementi, ma il valore può cambiare prima dell’operazione successiva; non usarlo per verificare se un successivo inserimento o prelievo avrà esito positivo.

BlockingQueue.put(e) attende che ci sia spazio, mentre BlockingQueue.take() attende un elemento e lo rimuove. Possono attendere a tempo indeterminato. Le varianti offer(e, timeout, unit) e poll(timeout, unit) limitano l’attesa e restituiscono rispettivamente false o null se il tempo scade senza successo. Le operazioni in attesa dichiarano InterruptedException; propaga l’eccezione oppure gestisci l’interruzione senza ignorarla silenziosamente.

Gli elementi non possono essere null. Le singole operazioni sulla coda sono atomiche, ma una sequenza di chiamate non diventa atomica per questo. L’interfaccia non dispone di un’operazione integrata di chiusura; per terminare serve un protocollo separato.

L’esempio con un solo thread mostra in modo deterministico gli stati pieno e vuoto. put e take possono terminare subito perché sono disponibili, rispettivamente, spazio ed un elemento; l’esempio non mostra l’attesa tra thread.

Esempi

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

public class Main {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(1);

        System.out.println(queue.offer("A"));
        System.out.println(queue.offer("B"));
        System.out.println(queue.peek());
        System.out.println(queue.size());
        System.out.println(queue.poll());
        System.out.println(queue.poll());

        queue.put("C");
        System.out.println(queue.take());
        System.out.println(queue.size());
    }
}

Risultato

true
false
A
1
A
null
C
0

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti