Flow Classe

Definição

[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

Herança

Object

JavaObject

Object

Flow

Atributos

RegisterAttribute

Comentários

Interfaces interrelacionadas e métodos estáticos para estabelecer componentes controlados por fluxo nos quais Publisher Publishers produzem itens consumidos por um ou mais Subscriber Subscribers, cada um gerenciado por um Subscription Subscription.

Essas interfaces correspondem à especificação de fluxos reativos . Elas se aplicam em configurações assíncronas simultâneas e distribuídas: todos (sete) métodos são definidos no void estilo de mensagem "unidirecional". A comunicação depende de uma forma simples de controle de fluxo (método Subscription#request) que pode ser usada para evitar problemas de gerenciamento de recursos que, de outra forma, podem ocorrer em sistemas baseados em "push".

<b>Exemplos.</b> A Publisher geralmente define sua própria Subscription implementação; construir uma no método subscribe e emiti-la para a chamada Subscriber. Ele publica itens no assinante de forma assíncrona, normalmente usando um Executor. Por exemplo, aqui está um editor muito simples que só emite (quando solicitado) um único TRUE item para um único assinante. Como o assinante recebe apenas um único item, essa classe não usa controle de buffer e ordenação necessário na maioria das implementações.

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

Um Subscriber organiza que os itens sejam solicitados e processados. Itens (invocações de Subscriber#onNext) não são emitidos, a menos que solicitados, mas vários itens podem ser solicitados. Muitas implementações do Assinante podem organizar isso no estilo do exemplo a seguir, em que um tamanho de buffer de 1 etapas simples e tamanhos maiores geralmente permitem um processamento sobreposto mais eficiente com menos comunicação; por exemplo, com um valor de 64, isso mantém o total de solicitações pendentes entre 32 e 64. Como as invocações de método do Assinante para um determinado determinado Subscription são estritamente ordenadas, não há necessidade desses métodos usarem bloqueios ou voláteis, a menos que um Assinante mantenha várias Assinaturas (nesse caso, é melhor definir vários Assinantes, cada um com sua própria Assinatura).

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

O valor padrão pode fornecer um ponto de #defaultBufferSize partida útil para escolher tamanhos e capacidades de solicitação em componentes do Flow com base nas taxas, recursos e usos esperados. Ou, quando o controle de fluxo nunca é necessário, um assinante pode inicialmente solicitar um número efetivamente não associado de itens, como em:

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

Adicionado em 9.

Java documentação para java.util.concurrent.Flow.

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na Creative Commons 2.5.