SubmissionPublisher Clase

Definición

[Android.Runtime.Register("java/util/concurrent/SubmissionPublisher", ApiSince=33, DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public class SubmissionPublisher : Java.Lang.Object, IDisposable, Java.Lang.IAutoCloseable, Java.Util.Concurrent.Flow.IPublisher

[<Android.Runtime.Register("java/util/concurrent/SubmissionPublisher", ApiSince=33, DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
type SubmissionPublisher = class
    inherit Object
    interface IAutoCloseable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable
    interface Flow.IPublisher

Herencia

Object

JavaObject

Object

SubmissionPublisher

Atributos

RegisterAttribute JavaTypeParametersAttribute

Implementaciones

IJavaObject IJavaPeerable IAutoCloseable Flow.IPublisher IDisposable

Comentarios

que Flow.Publisher emite de forma asincrónica elementos enviados (no NULL) a los suscriptores actuales hasta que se cierra. Cada suscriptor actual recibe los elementos recién enviados en el mismo orden a menos que se encuentren caídas o excepciones. El uso de submissionPublisher permite que los generadores de elementos actúen como publicadores reactivos compatibles que dependen del control de caídas o del bloqueo para el control de flujo.

Un objeto SubmissionPublisher usa el Executor proporcionado en su constructor para su entrega a los suscriptores. La mejor opción de Executor depende del uso esperado. Si los generadores de elementos enviados se ejecutan en subprocesos independientes y se puede estimar el número de suscriptores, considere la posibilidad de usar .Executors#newFixedThreadPool De lo contrario, considere la posibilidad de usar el valor predeterminado, normalmente .ForkJoinPool#commonPool

El almacenamiento en búfer permite a los productores y consumidores operar transitoriamente a diferentes velocidades. Cada suscriptor usa un búfer independiente. Los búferes se crean al usar por primera vez y se expanden según sea necesario hasta el máximo especificado. (La capacidad aplicada se puede redondear hasta la potencia más cercana de dos o limitadas por el valor más grande admitido por esta implementación). Las invocaciones de Flow.Subscription#request(long) request no generan directamente la expansión del búfer, pero la saturación del riesgo si las solicitudes no rellenadas superan la capacidad máxima. El valor predeterminado de puede proporcionar un punto de Flow#defaultBufferSize() partida útil para elegir una capacidad en función de las tasas, los recursos y los usos esperados.

Un único SubmissionPublisher puede compartirse entre varios orígenes. Acciones en un subproceso de origen antes de publicar un elemento o emitir una señal <i>acciones< anteriores/i> posteriores al acceso correspondiente por cada suscriptor. Pero las estimaciones notificadas de retraso y demanda están diseñadas para su uso en la supervisión, no para el control de sincronización, y pueden reflejar vistas obsoletas o inexactas del progreso.

Los métodos de publicación admiten diferentes directivas sobre qué hacer cuando los búferes están saturados. Los bloques de métodos #submit(Object) submit se bloquean hasta que los recursos estén disponibles. Esto es más sencillo, pero menos sensible. Los offer métodos pueden quitar elementos (inmediatamente o con tiempo de espera limitado), pero proporcionan una oportunidad para interponer un controlador y, a continuación, volver a intentarlo.

Si algún método de suscriptor produce una excepción, se cancela su suscripción. Si se proporciona un controlador como argumento de constructor, se invoca antes de la cancelación tras una excepción en el método Flow.Subscriber#onNext onNext, pero las excepciones de los métodos Flow.Subscriber#onSubscribe onSubscribe, Flow.Subscriber#onError(Throwable) onError y Flow.Subscriber#onComplete() onComplete no se registran ni controlan antes de la cancelación. Si el ejecutor proporcionado inicia RejectedExecutionException (o cualquier otro RuntimeException o Error) al intentar ejecutar una tarea, o un controlador de colocación produce una excepción al procesar un elemento descartado, la excepción se vuelve a iniciar. En estos casos, no todos los suscriptores habrán sido emitidos el elemento publicado. Normalmente, es recomendable hacerlo #closeExceptionally closeExceptionally en estos casos.

El método #consume(Consumer) simplifica la compatibilidad con un caso común en el que la única acción de un suscriptor es solicitar y procesar todos los elementos mediante una función proporcionada.

Esta clase también puede servir como una base cómoda para las subclases que generan elementos y usar los métodos de esta clase para publicarlos. Por ejemplo, esta es una clase que publica periódicamente los elementos generados a partir de un proveedor. (En la práctica, puede agregar métodos para iniciar y detener la generación de forma independiente, para compartir ejecutores entre publicadores, etc., o usar un SubmissionPublisher como componente en lugar de una superclase).

{@code
            class PeriodicPublisher<T> extends SubmissionPublisher<T> {
              final ScheduledFuture<?> periodicTask;
              final ScheduledExecutorService scheduler;
              PeriodicPublisher(Executor executor, int maxBufferCapacity,
                                Supplier<? extends T> supplier,
                                long period, TimeUnit unit) {
                super(executor, maxBufferCapacity);
                scheduler = new ScheduledThreadPoolExecutor(1);
                periodicTask = scheduler.scheduleAtFixedRate(
                  () -> submit(supplier.get()), 0, period, unit);
              }
              public void close() {
                periodicTask.cancel(false);
                scheduler.shutdown();
                super.close();
              }
            }}

Este es un ejemplo de una Flow.Processor implementación. Usa solicitudes de un solo paso a su publicador para simplificar la ilustración. Una versión más adaptable podría supervisar el flujo mediante la estimación de retraso devuelta de submit, junto con otros métodos de utilidad.

{@code
            class TransformProcessor<S,T> extends SubmissionPublisher<T>
              implements Flow.Processor<S,T> {
              final Function<? super S, ? extends T> function;
              Flow.Subscription subscription;
              TransformProcessor(Executor executor, int maxBufferCapacity,
                                 Function<? super S, ? extends T> function) {
                super(executor, maxBufferCapacity);
                this.function = function;
              }
              public void onSubscribe(Flow.Subscription subscription) {
                (this.subscription = subscription).request(1);
              }
              public void onNext(S item) {
                subscription.request(1);
                submit(function.apply(item));
              }
              public void onError(Throwable ex) { closeExceptionally(ex); }
              public void onComplete() { close(); }
            }}

Agregado en 9.

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

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.