How to use Java 9 Flow Interfaces / what's the point of including them in Java 9?

user_4945535 0
Viewed 1137

First I have to say that I have not much experience with Reactive Programming.

Since there are only a few interfaces in JDK 9 (Flow and its nested interfaces), JDK 9 obviously does not include a reactive library like RxJava.

In the Javadoc, there are some examples for implentations of Publisher, Subscription, and Subscriber. But these seem to be quite low-level and do not have any reactive operators or handling of back-pressure.

So what is the point of including those interfaces into the JDK?

Are vendors of reactive libraries supposed to use them, so that Java implementations (like RxJava) of those use a common set of interfaces? (similar to JPA and Hibernate?)

java-9 rx-java reactive-programming java
2 Answers

It mainly allows Java itself to use reactive programming internally in some future version, such as Reactive JDBC, Networking, IO, etc. In concept, it also serves as a new rally point for interoperation, however, such rally point already exists with Reactive Streams targeting a much larger audience via its Java 6 requirement.

As you mentioned, having that 4 interfaces and the SubmissionPublisher by itself has limited use. If Java had extension methods similar to Kotlin and C#, the inclusion of the interfaces could have much more interesting impact.

Unfortunately, it also means that existing libraries have to use bridges to convert between Java 9 Flow and Reactive-Streams and/or reimplement the whole library with Java 9 Flow API - cutting out anybody without Java 9 (i.e., Android).

Major libraries have already such bridges (RxJava 2 Jdk 9 Interop, Reactor-Core Interop) and the Reactive-Streams will have its own bridge eventually. There is also a prototype reactive library written for and with Java 9 features.

user_611580

The aim of flow interface is to provide "a standard for asynchronous stream processing with non-blocking back pressure". There are already a lot of solutions that achieve that (like Rx), but by introducing a common interface it maximizes interoperability.

the back pressure is the key point, back pressure being, that if the producer gives a callback, the consumer can call that callback at a rate faster than what the producer can handle.

It is easy to achiever BLOCKING back pressure by running them on the same thread so that the consumer and producer block each other.

This Flow interface will allow us to achieve NON BLOCKING back pressure.

The details of which are explained in more detail in this link (and also information on how to use the interface): https://aboullaite.me/java-9-new-features-reactive-streams/

user_62471590
Related