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

Object

Flow

Atributos

RegisterAttribute

Comentários

Interfaces inter-relacionadas 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. Eles se aplicam em configurações assíncronas simultâneas e distribuídas: Todos os (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, poderiam ocorrer em sistemas baseados em "push".

<b>Exemplos.</b> A Publisher geralmente define sua própria Subscription implementação, construindo uma no método subscribe e emitindo para a chamada Subscriber. Ele publica itens para o assinante de forma assíncrona, normalmente usando um Executorarquivo . 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 o 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);
                }
              }
            }}

A Subscriber organiza que os itens sejam solicitados e processados. Os itens (invocações de ) não são emitidos a Subscriber#onNextmenos que solicitados, mas vários itens podem ser solicitados. Muitas implementações do Assinante podem organizar isso no estilo do exemplo a seguir, onde um tamanho de buffer de 1 etapa única 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 chamadas do método do Assinante para um 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 de pode fornecer um ponto de partida útil para escolher tamanhos e capacidades de solicitação em componentes de #defaultBufferSize fluxo com base em taxas, recursos e usos esperados. Ou, quando o controle de fluxo nunca é necessário, um assinante pode solicitar inicialmente um número efetivamente ilimitado 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.

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

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

Propriedades

Métodos

Implantações explícitas de interface

Métodos de Extensão

Aplica-se a