CKTIS / Java
Flow.Subscriber — recevoir des éléments en contrôlant la demande
Flow.Subscriber<T> reçoit les éléments et les signaux terminaux d’un éditeur. Son abonnement lui permet d’exprimer une demande avec request(n) et de contrôler ainsi le nombre d’éléments transmis.
Version : Java SE 21; repository runtime, production runtime not attested
Syntaxe
class Receiver<T> implements Flow.Subscriber<T> {
public void onSubscribe(Flow.Subscription subscription) { }
public void onNext(T item) { }
public void onError(Throwable throwable) { }
public void onComplete() { }
}Flow.Subscriber<T> de java.util.concurrent est une interface de réception. T indique le type d’élément. Les appels associés à un même Flow.Subscription sont strictement séquentiels ; cela ne signifie pas qu’ils sont rattachés à un seul thread.
Flow.Subscriber.onSubscribe(Flow.Subscription subscription) reçoit l’abonnement avant les autres méthodes. Enregistrez-le et demandez des éléments. Flow.Subscriber.onNext(T item) traite un élément. request(n) ajoute de la demande au lieu de remplacer la demande précédente. Sur un abonnement actif, un appel à request(n) avec n <= 0 déclenche un signal onError avec IllegalArgumentException. Après l’annulation de l’abonnement ou après un signal terminal, un appel à request(n) ne déclenche pas de nouveau signal onError. Aucun élément n’est transmis sans demande. C’est le contrôle de flux, ou backpressure.
Flow.Subscriber.onError(Throwable throwable) signale une erreur irrécupérable, tandis que Flow.Subscriber.onComplete() signale une fin normale. Ces deux signaux sont terminaux : après l’un ou l’autre, l’abonnement n’appelle plus aucune méthode du récepteur. N’utilisez pas les exceptions levées par les méthodes du récepteur comme protocole d’erreur : l’interface ne garantit alors pas la suite correcte du comportement. cancel() est exécuté au mieux : des messages peuvent encore arriver et aucun signal terminal n’est garanti.
L’exemple utilise SubmissionPublisher et ne demande l’élément suivant qu’après avoir traité le courant. close() met fin à la publication, mais ne remplace pas l’attente de la livraison ; done.join() attend que le récepteur ait terminé. L’exemple montre le parcours normal ; une erreur termine done de façon exceptionnelle.
Exemples
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;
public class Main {
static final class Receiver implements Flow.Subscriber<Integer> {
private Flow.Subscription subscription;
final CompletableFuture<Void> done = new CompletableFuture<>();
@Override
public void onSubscribe(Flow.Subscription subscription) {
this.subscription = subscription;
subscription.request(1);
}
@Override
public void onNext(Integer item) {
System.out.println("item=" + item);
subscription.request(1);
}
@Override
public void onError(Throwable throwable) {
done.completeExceptionally(throwable);
}
@Override
public void onComplete() {
System.out.println("complete");
done.complete(null);
}
}
public static void main(String[] args) {
Receiver receiver = new Receiver();
try (SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>()) {
publisher.subscribe(receiver);
publisher.submit(10);
publisher.submit(20);
}
receiver.done.join();
}
}Résultat
item=10 item=20 complete
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.