Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

BlockingQueue – fronta s čekajícími operacemi

BlockingQueue<E> umožňuje bezpečnou výměnu prvků mezi vlákny, například mezi producentem a konzumentem. Rozlišuje operace, které nečekají na místo ani na prvky, čekající operace a varianty s časovým limitem. Příklad používá ArrayBlockingQueue s kapacitou 1.

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

Syntaxe

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> z balíčku java.util.concurrent rozšiřuje Queue<E>. Její implementace jsou bezpečné pro souběžné použití ve vláknech a slouží mimo jiné ke komunikaci mezi producentem a konzumentem. Kapacita a pořadí závisejí na implementaci: ArrayBlockingQueue má pevnou kapacitu a pořadí FIFO; samotné rozhraní FIFO nezaručuje.

BlockingQueue.offer(e) po vložení vrátí true, nebo vrátí false, pokud není místo. BlockingQueue.poll() odebere a vrátí první prvek, případně vrátí null, je-li fronta prázdná. BlockingQueue.peek() přečte první prvek, aniž by jej odebral, a při prázdné frontě vrátí null. Tyto varianty nečekají na místo ani na prvky. BlockingQueue.size() vrací počet prvků, ale tato hodnota se může před další operací změnit; nepoužívejte ji ke zjištění, zda pozdější vložení nebo odebrání uspěje.

BlockingQueue.put(e) čeká na volné místo, zatímco BlockingQueue.take() čeká na prvek a odebere jej. Čekání může být neomezené. Varianty offer(e, timeout, unit) a poll(timeout, unit) čekání omezují a při neúspěšném vypršení času vrátí false, respektive null. Čekající operace deklarují InterruptedException; výjimku předejte dál nebo přerušení zpracujte, aniž byste je tiše ignorovali.

Prvky nesmějí být null. Jednotlivé operace s frontou jsou atomické, ale posloupnost volání se tím atomickou nestává. Rozhraní nemá vestavěnou operaci pro uzavření; ukončení vyžaduje samostatný protokol.

Příklad s jedním vláknem deterministicky ukazuje plný a prázdný stav. put a take mohou skončit okamžitě, protože je k dispozici volné místo, respektive prvek; příklad neukazuje čekání mezi vlákny.

Příklady

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());
    }
}

Výsledek

true
false
A
1
A
null
C
0

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje