CKTIS / Java
BlockingQueue: vkládání, odebírání a čtení prvků
Vyberte si mezi okamžitou operací, čekáním s časovým limitem a čekáním bez něj. Zjistěte, jak nahlédnout do fronty a kdy platí pořadí FIFO.
Verze: Java SE 21
Syntaxe
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> je fronta bezpečná pro souběžnou práci vláken, například pro předávání práce od producentů ke konzumentům. offer(e) nečeká na místo: vrací true po vložení prvku nebo false, pokud není místo. offer(e, timeout, unit) v případě potřeby na místo čeká a vrací false, pokud časový limit vyprší dříve, než se místo uvolní. put(e) má návratový typ void a na místo v případě potřeby čeká bez časového limitu.
poll() odebere a vrátí prvek z čela fronty, nebo vrátí null, je-li fronta prázdná, aniž by čekala na prvek. poll(timeout, unit) také odebere a vrátí prvek z čela, ale může na něj čekat; pokud limit vyprší bez dostupného prvku, vrátí null. take() odebere a vrátí prvek z čela a v případě potřeby čeká bez časového limitu. Obě přetížení s limitem používají TimeUnit, například 1, TimeUnit.MILLISECONDS. Tato přetížení i put a take vyvolají InterruptedException, pokud je vlákno během čekání přerušeno.
peek(), zděděná z Queue, vrátí prvek z čela bez odebrání nebo null, je-li fronta prázdná. size(), zděděná z Collection, vrátí počet prvků jako int, nikoli kapacitu. Pokud fronta obsahuje více než Integer.MAX_VALUE prvků, metoda vrátí Integer.MAX_VALUE. Jiné vlákno může frontu mezi voláními změnit: size() > 0 nezaručuje, že následující take() nebude čekat. Vložení null pomocí offer nebo put vyvolá NullPointerException.
ArrayBlockingQueue má pevnou kapacitu; u LinkedBlockingQueue lze zadat kapacitní limit. Obě používají pořadí FIFO: ze zbývajících prvků se nejdřív odebere ten, který byl vložen nejdříve. Samotné rozhraní pořadí FIFO nezaručuje. PriorityBlockingQueue odebírá nejmenší prvek podle přirozeného pořadí nebo zadaného komparátoru; u shodně řazených prvků pořadí nezaručuje. Nemá vlastní kapacitní limit, takže její put ani časovaná varianta offer na místo nečekají.
Příklady
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());
}
}
Výsledek
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
Dva prvky zaplní frontu FIFO. `peek()` ukáže `20`, ale počet prvků zůstane `2`. `take()` odebere `20` a potom `poll()` odebere `10`. Obě volání s limitem `1` ms ukazují výsledky při neúspěchu, nikoli uplynulý čas. Prioritní fronta odebere jako první `10`.
Související lekce
- Java · Lekce 37 · Pokročilá · Verze: 2