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

CKTIS / Java

Flow.Publisher — publier des éléments avec contrôle de la demande

Flow.Publisher<T> décrit une source d’éléments reçus par des abonnés. Sa méthode subscribe relie un récepteur à la source, tandis que Flow.Subscription lui permet de demander des éléments et d’annuler la réception.

Version : Java SE 21; repository runtime, production runtime not attested

Syntaxe

Flow.Publisher<T>
void subscribe(Flow.Subscriber<? super T> subscriber)

Flow.Publisher<T> est une interface fonctionnelle de java.util.concurrent. Flow.Publisher.subscribe a pour signature void subscribe(Flow.Subscriber<? super T> subscriber). Le joker ? super T accepte un récepteur de type T ou d’un supertype. Un récepteur accepté reçoit onSubscribe avec un objet Flow.Subscription ; un argument null provoque NullPointerException. Un abonnement en double ou un refus dû à une politique ou à une erreur est signalé par onError avec IllegalStateException.

L’appel de subscribe ne crée pas, à lui seul, de demande. request(n) ajoute une demande pouvant porter sur jusqu’à n éléments supplémentaires ; si n <= 0, onError est appelé avec IllegalArgumentException. Il s’agit de rétropression (backpressure), et non d’une garantie de recevoir exactement n éléments. cancel() arrête la réception au mieux : des messages peuvent encore arriver et aucun signal terminal n’est obligatoire.

Les éléments sont transmis par onNext ; onComplete indique une fin normale et onError une erreur. Aucun autre appel ne suit un signal terminal. Les appels d’un même abonnement sont ordonnés par la relation happens-before. Ne présumez ni de la relecture des éléments antérieurs ni d’une politique uniforme d’abandon : ces aspects dépendent de l’implémentation.

L’exemple utilise SubmissionPublisher comme implémentation et appelle subscribe au moyen d’une référence Flow.Publisher<Integer>. Le récepteur demande deux éléments. La fermeture de la source lance la fin normale, mais la réception étant asynchrone, CountDownLatch maintient le programme en vie jusqu’au traitement du signal terminal. Cette attente de démonstration n’a pas de délai maximal ; en production, il faut prévoir le cas où la fin ne survient pas.

Exemples

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch done = new CountDownLatch(1);
        try (SubmissionPublisher<Integer> source = new SubmissionPublisher<>()) {
            Flow.Publisher<Integer> publisher = source;
            publisher.subscribe(new Flow.Subscriber<Integer>() {
                public void onSubscribe(Flow.Subscription subscription) {
                    subscription.request(2);
                }

                public void onNext(Integer item) {
                    System.out.println(item);
                }

                public void onError(Throwable error) {
                    System.out.println("Error: " + error.getClass().getSimpleName());
                    done.countDown();
                }

                public void onComplete() {
                    System.out.println("Done");
                    done.countDown();
                }
            });
            source.submit(10);
            source.submit(20);
        }
        done.await();
    }
}

Résultat

10
20
Done

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