Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

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.

Sources