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

CKTIS / Java

Flux réactifs et backpressure en Java

Flux réactifs et backpressure en Java: Java 21 expose le contrat reactive streams avec Flow.Publisher, Subscriber, Subscription et Processor, la demande étant pilotée par request(long).

Version : Java SE 21 (JLS and Java SE API); examples verified on the repository Java runtime

Syntaxe

reactive streams

Java 21 expose le contrat reactive streams avec Flow.Publisher, Subscriber, Subscription et Processor, la demande étant pilotée par request(long).

Utilise Flow pour un pipeline asynchrone avec backpressure lorsque chaque Subscriber contrôle les éléments en vol ; SubmissionPublisher fournit un publisher tamponné.

Un Subscriber doit conserver sa Subscription dans onSubscribe et demander des éléments ; request(Long.MAX_VALUE) signifie demande illimitée et onNext bloquant peut arrêter la livraison.

Un request non positif termine l’abonné par onError avec IllegalArgumentException ; aucun signal ne suit onError ou onComplete et cancel arrête la demande.

L’ordre onSubscribe, onNext:1, onNext:2, onNext:3, onComplete montre un Subscriber qui demande exactement un élément après chaque signal et reçoit une seule terminaison.

Exemples

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

public class Main {
    static final class OneAtATime implements Flow.Subscriber<Integer> {
        private final CountDownLatch done;
        private Flow.Subscription subscription;

        OneAtATime(CountDownLatch done) { this.done = done; }

        @Override public void onSubscribe(Flow.Subscription subscription) {
            this.subscription = subscription;
            System.out.println("onSubscribe");
            subscription.request(1);
        }

        @Override public void onNext(Integer item) {
            System.out.println("onNext:" + item);
            subscription.request(1);
        }

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

        @Override public void onComplete() {
            System.out.println("onComplete");
            done.countDown();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        var done = new CountDownLatch(1);
        var publisher = new SubmissionPublisher<Integer>(Runnable::run, 1);
        publisher.subscribe(new OneAtATime(done));
        publisher.submit(1);
        publisher.submit(2);
        publisher.submit(3);
        publisher.close();
        done.await();
    }
}

Résultat

onSubscribe
onNext:1
onNext:2
onNext:3
onComplete

L’ordre onSubscribe, onNext:1, onNext:2, onNext:3, onComplete montre un Subscriber qui demande exactement un élément après chaque signal et reçoit une seule terminaison.

Sources