Flow Classe

Définition

[Android.Runtime.Register("java/util/concurrent/Flow", ApiSince=30, DoNotGenerateAcw=true)]
public sealed class Flow : Java.Lang.Object

[<Android.Runtime.Register("java/util/concurrent/Flow", ApiSince=30, DoNotGenerateAcw=true)>]
type Flow = class
    inherit Object

Héritage

Object

Object

Flow

Attributs

RegisterAttribute

Remarques

Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels Publisher Publishers produisent des éléments consommés par un ou plusieurs Subscriber Subscribers, chacun géré par un Subscription Subscription.

Ces interfaces correspondent à la spécification des flux réactifs . Ils s’appliquent aux paramètres asynchrones simultanés et distribués : toutes les méthodes (sept) sont définies dans le void style de message unidirectionnel. La communication s’appuie sur une forme simple de contrôle de flux (méthode Subscription#request) qui peut être utilisée pour éviter les problèmes de gestion des ressources qui peuvent autrement se produire dans les systèmes basés sur « push ».

<b>Exemples.</b> A Publisher définit généralement sa propre Subscription implémentation ; la construction d’une méthode subscribe et son émission à l’appel Subscriber. Il publie des éléments de manière asynchrone sur l’abonné, normalement à l’aide d’un Executor. Par exemple, voici un éditeur très simple qui émet uniquement (lorsque demandé) un seul TRUE élément à un seul abonné. Étant donné que l’abonné ne reçoit qu’un seul élément, cette classe n’utilise pas le contrôle de mise en mémoire tampon et de classement requis dans la plupart des implémentations.

{@code
            class OneShotPublisher implements Publisher<Boolean> {
              private final ExecutorService executor = ForkJoinPool.commonPool(); // daemon-based
              private boolean subscribed; // true after first subscribe
              public synchronized void subscribe(Subscriber<? super Boolean> subscriber) {
                if (subscribed)
                  subscriber.onError(new IllegalStateException()); // only one allowed
                else {
                  subscribed = true;
                  subscriber.onSubscribe(new OneShotSubscription(subscriber, executor));
                }
              }
              static class OneShotSubscription implements Subscription {
                private final Subscriber<? super Boolean> subscriber;
                private final ExecutorService executor;
                private Future<?> future; // to allow cancellation
                private boolean completed;
                OneShotSubscription(Subscriber<? super Boolean> subscriber,
                                    ExecutorService executor) {
                  this.subscriber = subscriber;
                  this.executor = executor;
                }
                public synchronized void request(long n) {
                  if (!completed) {
                    completed = true;
                    if (n <= 0) {
                      IllegalArgumentException ex = new IllegalArgumentException();
                      executor.execute(() -> subscriber.onError(ex));
                    } else {
                      future = executor.submit(() -> {
                        subscriber.onNext(Boolean.TRUE);
                        subscriber.onComplete();
                      });
                    }
                  }
                }
                public synchronized void cancel() {
                  completed = true;
                  if (future != null) future.cancel(false);
                }
              }
            }}

Une Subscriber organisation permet de demander et de traiter les éléments. Les éléments (appels de Subscriber#onNext) ne sont pas émis, sauf si demandés, mais plusieurs éléments peuvent être demandés. De nombreuses implémentations d’Abonné peuvent les organiser dans le style de l’exemple suivant, où une taille de mémoire tampon de 1 étape unique et des tailles plus grandes permettent généralement un traitement superposé plus efficace avec moins de communication ; par exemple, avec une valeur de 64, cela conserve le nombre total de demandes en attente comprises entre 32 et 64. Étant donné que les appels de méthode de l’Abonné pour une donnée Subscription sont strictement ordonnés, il n’est pas nécessaire d’utiliser ces méthodes pour utiliser des verrous ou des volatiles, sauf si un Abonné gère plusieurs abonnements (auquel cas il est préférable de définir plutôt plusieurs Abonnés, chacun avec son propre abonnement).

{@code
            class SampleSubscriber<T> implements Subscriber<T> {
              final Consumer<? super T> consumer;
              Subscription subscription;
              final long bufferSize;
              long count;
              SampleSubscriber(long bufferSize, Consumer<? super T> consumer) {
                this.bufferSize = bufferSize;
                this.consumer = consumer;
              }
              public void onSubscribe(Subscription subscription) {
                long initialRequestSize = bufferSize;
                count = bufferSize - bufferSize / 2; // re-request when half consumed
                (this.subscription = subscription).request(initialRequestSize);
              }
              public void onNext(T item) {
                if (--count <= 0)
                  subscription.request(count = bufferSize - bufferSize / 2);
                consumer.accept(item);
              }
              public void onError(Throwable ex) { ex.printStackTrace(); }
              public void onComplete() {}
            }}

La valeur par défaut de peut fournir un point de #defaultBufferSize départ utile pour choisir des tailles et des capacités de requête dans les composants Flow en fonction des taux, ressources et utilisations attendus. Ou, lorsque le contrôle de flux n’est jamais nécessaire, un abonné peut demander initialement un nombre d’éléments sans limite, comme dans :

{@code
            class UnboundedSubscriber<T> implements Subscriber<T> {
              public void onSubscribe(Subscription subscription) {
                subscription.request(Long.MAX_VALUE); // effectively unbounded
              }
              public void onNext(T item) { use(item); }
              public void onError(Throwable ex) { ex.printStackTrace(); }
              public void onComplete() {}
              void use(T item) { ... }
            }}

Ajouté dans 9.

Documentation Java pour java.util.concurrent.Flow.

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 à