IBlockingQueue Interface

Définition

[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

Dérivé

Java.Util.Concurrent.ArrayBlockingQueue

Java.Util.Concurrent.DelayQueue

Java.Util.Concurrent.IBlockingDeque

Java.Util.Concurrent.ITransferQueue

Java.Util.Concurrent.LinkedBlockingDeque

Plus…

Attributs

RegisterAttribute JavaTypeParametersAttribute

Implémente

IJavaObject IJavaPeerable IIterable ICollection IQueue IDisposable

Remarques

Qui Queue prend également en charge les opérations qui attendent que la file d’attente devienne non vide lors de la récupération d’un élément et attend que l’espace soit disponible dans la file d’attente lors du stockage d’un élément.

BlockingQueue les méthodes se présentent sous quatre formes, avec différentes façons de gérer les opérations qui ne peuvent pas être satisfaites immédiatement, mais peuvent être satisfaites à un moment donné dans le futur : l’une lève une exception, la seconde retourne une valeur spéciale ( null soit false, en fonction de l’opération), les troisièmes blocs du thread actuel indéfiniment jusqu’à ce que l’opération puisse réussir, et les quatrième blocs pour une limite de temps maximale donnée seulement avant d’abandonner. Ces méthodes sont résumées dans le tableau suivant :

<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<#add(Object) add(e)<>> td/td><><#offer(Object) offer(e)/td/td#put(Object) put(e)<><>/td><><>#offer(Object, long, TimeUnit) offer(e, time, unit)</tr tr<>><th scope="row » style="text-align :left">Remove</th><td>#remove() remove()</td/td><>#poll() poll()<><td><#take() take()/td>>>#poll(long, TimeUnit) poll(time, unit)<<</tr tr><<>th scope="row » style="text-align :left">Examine</th<#element() element()<>> 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 n’accepte pas les null éléments. Implémentations levées NullPointerException sur des tentatives d’exécution ou putoffer d’un addnull. Un null est utilisé comme valeur sentinelle pour indiquer l’échec des poll opérations.

Une BlockingQueue capacité peut être limitée. À tout moment, il peut avoir un remainingCapacity au-delà duquel aucun élément supplémentaire ne peut être put sans blocage. Un BlockingQueue sans contraintes de capacité intrinsèques signale toujours une capacité restante de Integer.MAX_VALUE.

BlockingQueue Les implémentations sont conçues pour être utilisées principalement pour les files d’attente de producteur-consommateur, mais prennent également en charge l’interface Collection . Par exemple, il est possible de supprimer un élément arbitraire d’une file d’attente à l’aide remove(x)de . Toutefois, ces opérations sont en général effectuées de manière très <><> efficace et sont destinées à une utilisation occasionnelle, par exemple lorsqu’un message mis en file d’attente est annulé.

BlockingQueue les implémentations sont thread-safe. Toutes les méthodes de mise en file d’attente obtiennent leurs effets atomiquement à l’aide de verrous internes ou d’autres formes de contrôle d’accès concurrentiel. Toutefois, les <opérations addAllem>bulk</em> Collection , containsAllretainAll et removeAll ne sont <>pas</em> nécessairement effectuées atomiquement, sauf indication contraire dans une implémentation. Il est donc possible, par exemple, addAll(c) d’échouer (levée d’une exception) après avoir ajouté uniquement certains des éléments dans c.

A BlockingQueue ne prend>< pas< en> charge intrinsèquement n’importe quel type de " close" ou " shutdown" opération pour indiquer qu’aucun autre élément n’est ajouté. Les besoins et l’utilisation de ces fonctionnalités sont généralement dépendants de l’implémentation. Par exemple, une tactique courante est destinée aux producteurs d’insérer des objets spéciaux <em end-of-stream</em ou>< poison/em>>,< qui sont interprétés en conséquence lorsqu’ils sont pris par les>consommateurs.

Exemple d’utilisation, basé sur un scénario de producteur-consommateur classique. Notez qu’un BlockingQueue peut être utilisé en toute sécurité avec plusieurs producteurs et plusieurs consommateurs.

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

Effets de cohérence de la mémoire : comme avec d’autres collections simultanées, les actions d’un thread avant de placer un objet dans un BlockingQueue<i>happen-before</i> actions suite à l’accès ou à la suppression de cet élément dans BlockingQueue un autre thread.

Cette interface est membre de Java Collections Framework.

Ajouté à la version 1.5.

Documentation Java pour java.util.concurrent.BlockingQueue.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

Propriétés

Méthodes

Implémentations d’interfaces explicites

Méthodes d’extension

S’applique à