Reactive Streams

Reactive Streams is an initiative to provide a standard for asynchronous stream processing with non-blocking back pressure.^[1]

The main goal of Reactive Streams is to govern the exchange of stream data across an asynchronous boundary—like passing elements on to another thread or thread-pool—while ensuring that the receiving side is not forced to buffer arbitrary amounts of data. In other words, back pressure is an integral part of this model in order to allow the queues which mediate between threads to be bounded.

The intention of the specification is to allow the creation of many conforming implementations, which by virtue of abiding by the rules will be able to interoperate smoothly, preserving the mentioned benefits and characteristics across the whole processing graph of a stream application.

The scope of Reactive Streams is a minimal set of interfaces, methods and protocols that describe the necessary operations and entities to achieve the asynchronous streams of data with non-blocking back pressure. End-user DSLs or protocol binding APIs have purposefully been left out of the scope to encourage and enable different implementations that potentially use different programming languages to stay as true as possible to the idioms of their platform.

Reactive Streams started as an initiative in late 2013 between engineers at Netflix, Pivotal and Typesafe. Some of the earliest discussions began in 2013 between the Play and Akka teams at Typesafe.^[2][3] Typesafe is one of the main contributors of Reactive Streams.^[4] Other contributors include Red Hat, Oracle, Twitter and spray.io^[5] Work is under way to make the Java implementation of Reactive Streams part of Java 9: Doug Lea, leader of JSR 166, has proposed^[6] a new Flow class^[7] that will include the interfaces currently provided by Reactive Streams.^[4][8]

On April 30, 2015 version 1.0.0 of Reactive Streams for the JVM was released,^[4][5][9] including Java API,^[10] a textual specification,^[11] a TCK and implementation examples. It comes with a multitude of compliant implementations verified by the TCK for 1.0.0, listed in alphabetical order:

• Akka Streams^[12][13]
• MongoDB^[14]
• Ratpack^[15]
• Reactive Rabbit — driver for RabbitMQ/AMQP
• Spring and Pivotal Project Reactor^[16]
• Netflix RxJava^[17]
• Slick 3.0.^[18][19]
• Vert.x 3.0^[20]

Other implementations include Cassandra,^[21] Elasticsearch,^[22] Apache Kafka,^[23] Parallel Universe Quasar,^[24] Play Framework.^[25]

Spring 5 is announced to be built upon Reactive Streams compatible Reactor Core.^[26]

References

1. reactive-streams.org
2. A Journey into Reactive Streams
3. Reactive Streams 1.0.0 interview
4. Reactive Streams Releases First Stable Version for JVM
5. Reactive Streams 1.0.0 – a new standard in reactive data processing
6. jdk9 Candidate classes Flow and SubmissionPublisher
7. java.util.concurrent.Flow
8. JEP 266: More Concurrency Updates
9. Reactive Streams 1.0.0 is here!
10. Java API
11. Reactive Streams for the JVM specification
12. InfoQ: Reactive Streams with Akka Streams
13. Design Principles behind Akka Streams
14. MongoDB Reactive Streams Java Driver
15. Ratpack: The Reactive Streams API
16. Reactor 2.0.0.RC1 with native Reactive Streams support now available!
17. Advanced RxJava: The Reactive-Streams API (part 1)
18. Slick 3: Reactive Streams for Asynchronous Database Access in Scala
19. Slick 3.0.0
20. Vert.x Reactive Streams Integration
21. Accessing Cassandra in a Reactive Way
22. elastic4s — Non blocking, type safe DSL and Scala client for Elasticsearch
23. Reactive Streams for Apache Kafka
24. Quasar and Reactive Streams
25. Play Framework — Reactive Streams integration (experimental)
26. Reactive Spring

•  This article incorporates text from http://www.reactive-streams.org/, which is released under a CC0 1.0 Universal (CC0 1.0) Public Domain Dedication.