Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

BlockingQueue: inserire, estrarre e consultare gli elementi

Scegli tra operazioni immediate, attese con un limite di tempo e attese senza scadenza. Scopri come consultare la coda e quando si applica l’ordine FIFO.

Versione: Java SE 21

Sintassi

java.util.concurrent.BlockingQueue<E> — Java SE 21
boolean offer(E e);
boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException;
E poll();
E poll(long timeout, TimeUnit unit) throws InterruptedException;
void put(E e) throws InterruptedException;
E take() throws InterruptedException;
E peek();
int size();

java.util.concurrent.BlockingQueue<E> è una coda thread-safe, utile per passare lavoro dai produttori ai consumatori. offer(e) non attende che si liberi spazio: restituisce true se inserisce l’elemento o false se non c’è spazio. offer(e, timeout, unit) attende spazio se necessario e restituisce false se il tempo scade prima che se ne liberi. put(e) ha tipo di ritorno void e, se necessario, attende spazio senza limiti di tempo.

poll() rimuove e restituisce l’elemento in testa oppure restituisce null se la coda è vuota, senza attendere un elemento. poll(timeout, unit) rimuove e restituisce anch’esso l’elemento in testa, ma può attenderlo e restituisce null se il tempo scade prima che un elemento sia disponibile. take() rimuove e restituisce l’elemento in testa e, se necessario, lo attende senza limiti di tempo. Entrambi gli overload temporizzati usano TimeUnit, come in 1, TimeUnit.MILLISECONDS. Questi overload, put e take lanciano InterruptedException se il thread viene interrotto durante l’attesa.

peek(), ereditato da Queue, restituisce l’elemento in testa senza rimuoverlo, oppure null se la coda è vuota. size(), ereditato da Collection, restituisce il numero di elementi come int, non la capacità. Se la coda contiene più di Integer.MAX_VALUE elementi, il metodo restituisce Integer.MAX_VALUE. Un altro thread può modificare la coda tra due chiamate: size() > 0 non garantisce che il successivo take() non debba attendere. Inserire null con offer o put causa una NullPointerException.

ArrayBlockingQueue ha capacità fissa; con LinkedBlockingQueue si può specificare un limite di capacità. Entrambe seguono l’ordine FIFO: tra gli elementi ancora in coda, viene estratto per primo quello inserito prima. L’interfaccia non garantisce l’ordine FIFO. PriorityBlockingQueue estrae l’elemento minimo secondo l’ordinamento naturale o un comparatore fornito, senza un ordine garantito a parità di priorità. Non ha un limite di capacità intrinseco, quindi il suo put e il suo offer temporizzato non attendono spazio.

Esempi

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

public class BlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> fifo = new ArrayBlockingQueue<>(2);
        fifo.put(20);
        System.out.println("offer with space: " + fifo.offer(10));
        System.out.println("offer when full: " + fifo.offer(30));
        System.out.println("timed offer when full: "
                + fifo.offer(30, 1, TimeUnit.MILLISECONDS));
        System.out.println("peek: " + fifo.peek());
        System.out.println("size after peek: " + fifo.size());
        System.out.println("take: " + fifo.take());
        System.out.println("poll: " + fifo.poll());
        System.out.println("poll when empty: " + fifo.poll());
        System.out.println("timed poll when empty: "
                + fifo.poll(1, TimeUnit.MILLISECONDS));

        BlockingQueue<Integer> priority = new PriorityBlockingQueue<>();
        priority.put(20);
        priority.put(10);
        System.out.println("priority take: " + priority.take());
    }
}

Risultato

offer with space: true
offer when full: false
timed offer when full: false
peek: 20
size after peek: 2
take: 20
poll: 10
poll when empty: null
timed poll when empty: null
priority take: 10

Due elementi riempiono la coda FIFO. `peek()` mostra `20`, ma la dimensione resta `2`. `take()` estrae `20`, poi `poll()` estrae `10`. Le due chiamate con timeout di `1` ms mostrano i risultati in caso di mancato completamento, non il tempo trascorso. La coda di priorità estrae prima `10`.

Lezioni correlate

  • Java · Lezione 37 · Avanzato · Versione: 2

Fonti