Flow Clase

Definición

[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

Herencia

Object

JavaObject

Object

Flow

Atributos

RegisterAttribute

Comentarios

Interfaces y métodos estáticos relacionados para establecer componentes controlados por flujo en los que Publisher Publishers se producen elementos consumidos por uno o varios Subscriber Subscribers, cada uno administrado por .Subscription Subscription

Estas interfaces corresponden a la especificación de flujos reactivos . Se aplican tanto en la configuración asincrónica simultánea como distribuida: todos los métodos (siete) se definen en void el estilo de mensaje "unidireccional". La comunicación se basa en una forma sencilla de control de flujo (método Subscription#request) que se puede usar para evitar problemas de administración de recursos que pueden producirse en sistemas basados en "inserción".

<b>Ejemplos.</b> Normalmente Publisher define su propia Subscription implementación; construye una en el método subscribe y la emite a la llamada Subscribera . Publica elementos en el suscriptor de forma asincrónica, normalmente mediante .Executor Por ejemplo, este es un publicador muy sencillo que solo emite (cuando se solicita) un solo elemento a un solo TRUE suscriptor. Dado que el suscriptor recibe solo un solo elemento, esta clase no usa el almacenamiento en búfer ni el control de ordenación necesarios en la mayoría de las implementaciones.

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

Un Subscriber organiza que se solicitan y procesan los elementos. Los elementos (invocaciones de Subscriber#onNext) no se emiten a menos que se soliciten, pero se pueden solicitar varios elementos. Muchas implementaciones de suscriptor pueden organizar esto en el estilo del ejemplo siguiente, donde un tamaño de búfer de 1 solo pasos y tamaños más grandes normalmente permiten un procesamiento superpuesto más eficaz con menos comunicación; por ejemplo, con un valor de 64, esto mantiene el total de solicitudes pendientes entre 32 y 64. Dado que las invocaciones de método de suscriptor para un determinado Subscription están estrictamente ordenadas, no es necesario que estos métodos usen bloqueos o volátiles a menos que un suscriptor mantenga varias suscripciones (en cuyo caso es mejor definir varios suscriptores, cada uno con su propia suscripción).

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

El valor predeterminado de puede proporcionar un punto de #defaultBufferSize partida útil para elegir tamaños y capacidades de solicitud en componentes de Flow en función de las tasas, recursos y usos esperados. O bien, cuando nunca se necesita el control de flujo, un suscriptor puede solicitar inicialmente un número de elementos sin enlazar eficazmente, como en:

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

Agregado en 9.

Java documentación para java.util.concurrent.Flow.

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.