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

CKTIS / Java

Flow.Subscription — demande et annulation

Flow.Subscription contrôle la livraison des éléments entre un éditeur et un abonné. request(long n) augmente la demande, tandis que cancel() met fin à la réception sans garantir l’arrêt immédiat de la livraison.

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

Syntaxe

import java.util.concurrent.Flow;

Flow.Subscription subscription;
// Interface methods:
void request(long n);
void cancel();

Flow.Subscription relie un Flow.Publisher à un Flow.Subscriber. L’abonné la reçoit dans onSubscribe, avant les autres rappels. Ce mécanisme de contrôle du flux (backpressure) permet au destinataire d’indiquer combien d’éléments il est prêt à accepter ; sans demande, il ne reçoit aucun élément via onNext.

Flow.Subscription.request(long n) ajoute n à la demande en attente au lieu de la remplacer. Moins d’éléments peuvent arriver si le flux se termine. Long.MAX_VALUE peut représenter une demande pratiquement illimitée. Si l’abonnement est actif, un appel avec n <= 0 signale une IllegalArgumentException à l’abonné via onError : request ne lève pas cette exception de façon synchrone. Une fois l’abonnement annulé, request n’a aucun effet, même pour n <= 0.

Flow.Subscription.cancel() arrête la réception au mieux : d’autres messages peuvent encore arriver. Cela ne garantit ni onComplete ni onError. Les deux méthodes sont destinées uniquement à l’abonné associé ; toute autre utilisation a des effets indéfinis.

L’exemple utilise SubmissionPublisher avec l’exécuteur Runnable::run afin de livrer les tâches dans le thread courant sans risque de concurrence avec la fin du programme. L’abonné demande deux éléments et annule après le second. La sortie attendue est 10 et 20, chacun sur sa propre ligne, sans complete. Il s’agit d’un exemple Java SE 21, et non d’une attestation concernant un environnement de production.

Exemples

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

public class Main {
    public static void main(String[] args) {
        try (var publisher = new SubmissionPublisher<Integer>(Runnable::run, 4)) {
            publisher.subscribe(new Flow.Subscriber<Integer>() {
                private Flow.Subscription subscription;
                private int received;

                @Override
                public void onSubscribe(Flow.Subscription s) {
                    subscription = s;
                    subscription.request(2);
                }

                @Override
                public void onNext(Integer item) {
                    System.out.println(item);
                    if (++received == 2) {
                        subscription.cancel();
                    }
                }

                @Override
                public void onError(Throwable error) {
                    System.out.println(error.getClass().getSimpleName());
                }

                @Override
                public void onComplete() {
                    System.out.println("complete");
                }
            });
            publisher.submit(10);
            publisher.submit(20);
            publisher.submit(30);
        }
    }
}

Résultat

10
20

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