What is Java 9 Reactive Streams
“When Reactive Streams started their work, following the path established by the Reactive Manifesto, they indicated that their aim was to provide “a standard for asynchronous stream processing with non-blocking back pressure”. The main challenge, however, wasn’t to find a solution, in particular since there were already a number of them out there. The challenge was to coalesce the different existing patterns into a common one to maximise interoperability. More precisely, the objective of Reactive Streams was “to find a minimal set of interfaces, methods and protocols that will describe the necessary operations and entities to achieve the goal—asynchronous streams of data with non-blocking back pressure”.
The concept of “back pressure” is key. When an asynchronous consumer subscribes to receive messages from a producer, it will typically provide some form of callback method to be invoked whenever a new message becomes available. If the producer emits messages at a higher rate than the consumer can handle, the consumer could be forced to seize an increasing amount of resources and potentially crash. In order to prevent this, a mechanism is needed by which consumers can notify producers that the message rate needs to be reduced. Producers can then adopt one of multiple strategies to achieve this. This mechanism is called back pressure.
Blocking back pressure is easy to achieve. If, for instance, producer and consumer are running under the same thread, the execution of one will block the execution of the other. This means that, while the consumer is being executed, the producer cannot emit any new messages, and therefore a natural way to balance input and output occurs. However, there are scenarios where blocking back pressure is undesirable (for instance when a producer has multiple consumers, not all of them consuming messages at the same rate) or simply unattainable (for instance when consumer and producer run in different environments). In these cases it is necessary that the back pressure mechanism works in a non-blocking way.
The way to achieve non-blocking back pressure is to move from a push strategy, where the producer sends messages to the consumer as soon as these are available, to a pull strategy, where the consumer requests a number of messages to the producer and this sends only up to this amount, waiting for further requests before sending any more.” – Aboullaite
What’s the point of reactive programming in Java 9?
Well, the classes or interfaces present in Java 9 are the glue between the reactive streams implementations. Meaning, they automatically have back pressure between them.
The user API and features are the task of the respective libraries (implementations of reactive streams specifications: Akka streams or RxJava). The Java 9 package focuses on the API for Reactive Pull, a manner of coupling producing and consuming systems to ensure backpressure over an async boundary.
Thanks for reading our “Java 9 Reactive Streams” article. If you liked it, then please share with your friends and colleagues. If you have any feedback or doubt then please leave us a comment.
By the way, I am also really happy to announce some very exciting news: to celebrate the imminent release of Spring 5 and Java 9, we launched our simulators SALE CAMPAIGN. We halved the price of our simulators at www.springmockexams.com and www.javamockexams.com for limited time only. Take a look here bit.ly/SMEBP and here bit.ly/JMEBP
If you are interested in collaborating with us, you can join our partner program at bit.ly/SMEPART and here bit.ly/JMEPART