Flow Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels Publisher Publishers produisent des éléments consommés par un ou plusieurs Subscriber
Subscribers, chacun géré par un Subscription
Subscription.
[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- Héritage
- Attributs
Remarques
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels Publisher Publishers produisent des éléments consommés par un ou plusieurs Subscriber Subscribers, chacun géré par un Subscription Subscription.
Ces interfaces correspondent à la spécification des flux réactifs . Ils s’appliquent aux paramètres asynchrones simultanés et distribués : toutes les méthodes (sept) sont définies dans le void style de message unidirectionnel. La communication s’appuie sur une forme simple de contrôle de flux (méthode Subscription#request) qui peut être utilisée pour éviter les problèmes de gestion des ressources qui peuvent autrement se produire dans les systèmes basés sur « push ».
<b>Exemples.</b> A Publisher définit généralement sa propre Subscription implémentation ; la construction d’une méthode subscribe et son émission à l’appel Subscriber. Il publie des éléments de manière asynchrone sur l’abonné, normalement à l’aide d’un Executor. Par exemple, voici un éditeur très simple qui émet uniquement (lorsque demandé) un seul TRUE élément à un seul abonné. Étant donné que l’abonné ne reçoit qu’un seul élément, cette classe n’utilise pas le contrôle de mise en mémoire tampon et de classement requis dans la plupart des implémentations.
{@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);
}
}
}}
Une Subscriber organisation permet de demander et de traiter les éléments. Les éléments (appels de Subscriber#onNext) ne sont pas émis, sauf si demandés, mais plusieurs éléments peuvent être demandés. De nombreuses implémentations d’Abonné peuvent les organiser dans le style de l’exemple suivant, où une taille de mémoire tampon de 1 étape unique et des tailles plus grandes permettent généralement un traitement superposé plus efficace avec moins de communication ; par exemple, avec une valeur de 64, cela conserve le nombre total de demandes en attente comprises entre 32 et 64. Étant donné que les appels de méthode de l’Abonné pour une donnée Subscription sont strictement ordonnés, il n’est pas nécessaire d’utiliser ces méthodes pour utiliser des verrous ou des volatiles, sauf si un Abonné gère plusieurs abonnements (auquel cas il est préférable de définir plutôt plusieurs Abonnés, chacun avec son propre abonnement).
{@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() {}
}}
La valeur par défaut de peut fournir un point de #defaultBufferSize départ utile pour choisir des tailles et des capacités de requête dans les composants Flow en fonction des taux, ressources et utilisations attendus. Ou, lorsque le contrôle de flux n’est jamais nécessaire, un abonné peut demander initialement un nombre d’éléments sans limite, comme dans :
{@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) { ... }
}}
Ajouté dans 9.
Documentation Java pour java.util.concurrent.Flow.
Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.
Propriétés
| Class |
Retourne la classe runtime de ce |
| Handle |
Handle de l’instance Android sous-jacente. (Hérité de Object) |
| JniIdentityHashCode |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| JniPeerMembers |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| PeerReference |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| ThresholdClass |
Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code. (Hérité de Object) |
| ThresholdType |
Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code. (Hérité de Object) |
Méthodes
| Clone() |
Crée et retourne une copie de cet objet. (Hérité de Object) |
| DefaultBufferSize() |
Retourne une valeur par défaut pour la mise en mémoire tampon du serveur de publication ou de l’Abonné, qui peut être utilisée en l’absence d’autres contraintes. |
| Dispose() |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| Dispose(Boolean) |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| Equals(Object) |
Indique si un autre objet est « égal à » celui-ci. (Hérité de Object) |
| GetHashCode() |
Retourne une valeur de code de hachage pour l'objet. (Hérité de Object) |
| JavaFinalize() |
Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object) |
| Notify() |
Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object) |
| NotifyAll() |
Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object) |
| SetHandle(IntPtr, JniHandleOwnership) |
Définit la propriété Handle. (Hérité de Object) |
| ToArray<T>() |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| ToString() |
Retourne une représentation de chaîne de l'objet. (Hérité de Object) |
| UnregisterFromRuntime() |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| Wait() |
Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou> <em>interrompu</em>.<> (Hérité de Object) |
| Wait(Int64, Int32) |
Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object) |
| Wait(Int64) |
Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object) |
Implémentations d’interfaces explicites
| IJavaPeerable.Disposed() |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| IJavaPeerable.DisposeUnlessReferenced() |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| IJavaPeerable.Finalized() |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| IJavaPeerable.JniManagedPeerState |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
Méthodes d’extension
| JavaCast<TResult>(IJavaObject) |
Effectue une conversion de type vérifiée par le runtime Android. |
| JavaCast<TResult>(IJavaObject) |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |
| GetJniTypeName(IJavaPeerable) |
Interfaces liées et méthodes statiques permettant d’établir des composants contrôlés par flux dans lesquels |