Flow Classe

Definizione

[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

Ereditarietà

Object

JavaObject

Object

Flow

Attributi

RegisterAttribute

Commenti

Interfacce correlate e metodi statici per stabilire componenti controllati dal flusso in cui Publisher Publishers produrre elementi utilizzati da uno o più Subscriber Subscribers, ognuno gestito da un oggetto Subscription Subscription.

Queste interfacce corrispondono alla specifica di flussi reattivi . Si applicano in impostazioni asincrone simultanee e distribuite: tutti i metodi (sette) sono definiti in void stile messaggio "unidirezionale". La comunicazione si basa su una forma semplice di controllo del flusso (metodo Subscription#request) che può essere usata per evitare problemi di gestione delle risorse che altrimenti si verificano nei sistemi basati su "push".

<b>Esempi.</b> A Publisher definisce in genere la propria Subscription implementazione, creandone una nel metodo subscribe ed eseguendola alla chiamata Subscriberdi . Pubblica gli elementi nel sottoscrittore in modo asincrono, in genere usando un oggetto Executor. Ad esempio, di seguito è riportato un server di pubblicazione molto semplice che genera un solo TRUE elemento (quando richiesto) a un singolo sottoscrittore. Poiché il sottoscrittore riceve solo un singolo elemento, questa classe non usa il buffering e il controllo di ordinamento necessari nella maggior parte delle implementazioni.

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

Dispone Subscriber gli elementi da richiedere ed elaborare. Gli elementi (chiamate di Subscriber#onNext) non vengono emessi a meno che non venga richiesto, ma è possibile richiedere più elementi. Molte implementazioni del Sottoscrittore possono disporre questo aspetto nello stile dell'esempio seguente, in cui una dimensione del buffer di 1 singolo passaggio e dimensioni maggiori in genere consentono un'elaborazione più efficiente sovrapposta con una minore comunicazione; ad esempio con un valore pari a 64, questo mantiene il totale delle richieste in sospeso tra 32 e 64. Poiché le chiamate al metodo del Sottoscrittore per un determinato Subscription oggetto sono rigorosamente ordinate, non è necessario che questi metodi usino blocchi o volatili, a meno che un Sottoscrittore non gestisca più sottoscrizioni( in questo caso è preferibile definire invece più Sottoscrittori, ognuno con la propria sottoscrizione).

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

Il valore predefinito di #defaultBufferSize può fornire un punto di partenza utile per la scelta delle dimensioni e delle capacità delle richieste nei componenti di Flow in base a frequenze, risorse e utilizzi previsti. In alternativa, quando il controllo del flusso non è mai necessario, un sottoscrittore potrebbe inizialmente richiedere un numero di elementi effettivamente non associato, come in:

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

Aggiunta in 9.

per java.util.concurrent.Flow.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.