IBlockingQueue Schnittstelle

Definition

[Android.Runtime.Register("java/util/concurrent/BlockingQueue", "", "Java.Util.Concurrent.IBlockingQueueInvoker")]
[Java.Interop.JavaTypeParameters(new System.String[] { "E" })]
public interface IBlockingQueue : IDisposable, Java.Interop.IJavaPeerable, Java.Util.IQueue

[<Android.Runtime.Register("java/util/concurrent/BlockingQueue", "", "Java.Util.Concurrent.IBlockingQueueInvoker")>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "E" })>]
type IBlockingQueue = interface
    interface IQueue
    interface ICollection
    interface IIterable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Abgeleitet

Java.Util.Concurrent.ArrayBlockingQueue

Java.Util.Concurrent.DelayQueue

Java.Util.Concurrent.IBlockingDeque

Java.Util.Concurrent.ITransferQueue

Java.Util.Concurrent.LinkedBlockingDeque

Mehr …

Attribute

RegisterAttribute JavaTypeParametersAttribute

Implementiert

IJavaObject IJavaPeerable IIterable ICollection IQueue IDisposable

Hinweise

Eine Queue , die zusätzlich Vorgänge unterstützt, die warten, bis die Warteschlange beim Abrufen eines Elements nicht leer wird, und warten, bis Speicherplatz in der Warteschlange beim Speichern eines Elements verfügbar ist.

BlockingQueue Methoden kommen in vier Formen, mit unterschiedlichen Methoden zum Behandeln von Vorgängen, die nicht sofort erfüllt werden können, aber irgendwann in Der Zukunft zufrieden sein können: Eine Ausnahme löst eine Ausnahme aus, die zweite gibt einen speziellen Wert (entweder null oder false, je nach Vorgang) zurück, der dritte blockiert den aktuellen Thread unbegrenzt, bis der Vorgang erfolgreich sein kann, und die vierten Blöcke nur für eine bestimmte maximale Zeitgrenze, bevor sie aufgeben. Diese Methoden sind in der folgenden Tabelle zusammengefasst:

<table class="plain">caption Summary of BlockingQueue methods</caption><tr><td/td><>< th scope="col" style="font-weight:normal; font-style:italic">Throws exception</th th><scope="col" style="font-weight:normal; font-style:italic">Special value</th th<>scope="col" style="font-weight:normal; font-style:italic">Blocks</th th><scope="col" style="font-weight:normal;>< font-style:italic">Times out</th/tr tr><<>th>< scope="row" style="text-align:left">Insert</th><td<>#add(Object) add(e)/td><td>#offer(Object) offer(e)</<>td td<#put(Object) put(e)>/td td><><#offer(Object, long, TimeUnit) offer(e, time, unit)/td<>/tr tr<<>>th scope="row" style="text-align:left">Remove</th<>td#remove() remove()<>/td<>td/td/td>#poll() poll()<><td>#take() take()</td td><#poll(long, TimeUnit) poll(time, unit)/td></td<>/tr tr><><th scope="row" style="text-align:left">Examine</th<>td><#element() element()/td td<>td><#peek() peek()/td><td style="font-style: italic">not applicable</td td><style="font-style: italic">not applicable</td<>/tr></table>

A BlockingQueue akzeptiert null keine Elemente. Implementierungen werden NullPointerException auf Versuche, addput oder offer ein null. A null wird als Sentinelwert verwendet, um fehler bei Vorgängen poll anzuzeigen.

Eine BlockingQueue kann kapazitätsgebunden sein. Zu einem bestimmten Zeitpunkt kann es eine remainingCapacity Darüber hinaus haben, über die keine zusätzlichen Elemente ohne Blockierung verfügen put können. Eine BlockingQueue ohne systeminterne Kapazitätsbeschränkungen meldet immer eine verbleibende Kapazität von Integer.MAX_VALUE.

BlockingQueue Implementierungen sind in erster Linie für Produzenten-Consumer-Warteschlangen vorgesehen, unterstützen aber zusätzlich die Collection Schnittstelle. So ist es beispielsweise möglich, ein beliebiges Element mithilfe remove(x)einer Warteschlange aus einer Warteschlange zu entfernen. Solche Vorgänge werden jedoch im Allgemeinen <>nicht</em> sehr effizient ausgeführt und sind nur für gelegentliche Verwendung vorgesehen, z. B. wenn eine in die Warteschlange eingereihte Nachricht abgebrochen wird.

BlockingQueue Implementierungen sind threadsicher. Alle Queuing-Methoden erreichen ihre Auswirkungen atomisch mit internen Sperren oder anderen Formen der Parallelitätssteuerung. Die Em-Massen<-/Em-Sammlungsvorgänge>addAll, retainAllcontainsAllund removeAll sind <em>>nicht>< notwendigerweise atomisch ausgeführt, es sei denn, <dies ist in einer Implementierung anders angegeben. Es ist also möglich, addAll(c) z. B. fehlzuschlagen (Auslösen einer Ausnahme), nachdem nur einige der Elemente hinzugefügt wurden c.

A BlockingQueue unterstützt <>nicht</em> systemintern jede Art von " close" oder " Herunterfahren" operation to indicate that no more items will be added. Die Bedürfnisse und die Verwendung solcher Features sind in der Regel implementierungsabhängig. Eine häufige Taktik ist beispielsweise, dass Produzenten spezielle <em-end-of-stream<>/em>- oder <em>gift</em-Objekte> einfügen, die entsprechend interpretiert werden, wenn sie von Verbrauchern eingenommen werden.

Verwendungsbeispiel basierend auf einem typischen Szenario für Produzenten und Verbraucher. Beachten Sie, dass eine BlockingQueue sichere Verwendung mit mehreren Produzenten und mehreren Verbrauchern möglich ist.

{@code
            class Producer implements Runnable {
              private final BlockingQueue queue;
              Producer(BlockingQueue q) { queue = q; }
              public void run() {
                try {
                  while (true) { queue.put(produce()); }
                } catch (InterruptedException ex) { ... handle ...}
              }
              Object produce() { ... }
            }

            class Consumer implements Runnable {
              private final BlockingQueue queue;
              Consumer(BlockingQueue q) { queue = q; }
              public void run() {
                try {
                  while (true) { consume(queue.take()); }
                } catch (InterruptedException ex) { ... handle ...}
              }
              void consume(Object x) { ... }
            }

            class Setup {
              void main() {
                BlockingQueue q = new SomeQueueImplementation();
                Producer p = new Producer(q);
                Consumer c1 = new Consumer(q);
                Consumer c2 = new Consumer(q);
                new Thread(p).start();
                new Thread(c1).start();
                new Thread(c2).start();
              }
            }}

Auswirkungen auf die Speicherkonsistenz: Wie bei anderen gleichzeitigen Auflistungen werden Aktionen in einem Thread vor dem Platzieren eines Objekts in eine i-happen-before/i-Aktionen> ausgeführt, die auf den Zugriff oder das Entfernen dieses Elements aus dem BlockingQueue in einem BlockingQueue<anderen Thread folgen.><

Diese Schnittstelle ist ein Mitglied des Java Collections Framework.

Hinzugefügt in 1.5.

Java-Dokumentation für java.util.concurrent.BlockingQueue.

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die vom Android Open Source-Projekt erstellt und freigegeben werden und gemäß den in der Creative Commons 2.5 Attribution License beschriebenen Begriffen verwendet werden.

Eigenschaften

Methoden

Explizite Schnittstellenimplementierungen

Erweiterungsmethoden

Gilt für: