CKTIS / Java
Flow.Subscriber — elementen ontvangen met vraagcontrole
Flow.Subscriber<T> ontvangt elementen en eindsignalen van een publisher. Met de subscription kan de ontvanger via request(n) vraag aangeven en zo bepalen hoeveel elementen worden geleverd.
Versie: Java SE 21; repository runtime, production runtime not attested
Syntax
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> uit java.util.concurrent is een ontvangende interface. T geeft het elementtype aan. Aanroepen voor één Flow.Subscription verlopen strikt sequentieel; dat betekent niet dat ze aan één thread zijn gebonden.
Flow.Subscriber.onSubscribe(Flow.Subscription subscription) ontvangt de subscription vóór de andere methoden. Bewaar deze en vraag elementen aan. Flow.Subscriber.onNext(T item) verwerkt één element. request(n) voegt vraag toe in plaats van eerdere vraag te vervangen. Bij een actieve subscription leidt een aanroep van request(n) met n <= 0 tot een onError-signaal met IllegalArgumentException. Na annulering van de subscription of na een eindsignaal leidt een aanroep van request(n) niet tot een nieuw onError-signaal. Zonder vraag worden geen elementen geleverd. Dit is flow control, oftewel backpressure.
Flow.Subscriber.onError(Throwable throwable) geeft een onherstelbare fout aan, terwijl Flow.Subscriber.onComplete() normale voltooiing aangeeft. Beide zijn terminaal: na een van beide roept de subscription geen verdere methoden van de ontvanger aan. Gebruik uitzonderingen die uit ontvangermethoden worden gegooid niet als foutprotocol: de interface garandeert dan geen correct vervolg. cancel() werkt naar beste vermogen: er kunnen nog berichten aankomen en een terminaal signaal is niet gegarandeerd.
Het voorbeeld gebruikt SubmissionPublisher en vraagt pas een volgend element aan nadat het huidige is verwerkt. close() beëindigt het publiceren, maar vervangt het wachten op levering niet; done.join() wacht tot de ontvanger klaar is. Het voorbeeld toont het normale verloop; bij een fout wordt done uitzonderlijk voltooid.
Voorbeelden
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();
}
}Resultaat
item=10 item=20 complete
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.