reactive-streams / reactive-streams-jvm

Reactive Streams # The purpose of Reactive Streams is to provide a standard for asynchronous stream processing with non-blocking backpressure. The latest release is available on Maven Central as Goals, Design and Scope ## Handling streams of data—especially “live” data whose volume is not predetermined—requires special care in an asynchronous system. The most prominent issue is that resource consumption needs to be carefully controlled such that a fast data source does not overwhelm the stream destination. Asynchrony is needed in order to enable the parallel use of computing resources, on collaborating network hosts or multiple CPU cores within a single machine. The main goal of Reactive Streams is to govern the exchange of stream data across an asynchronous boundary – think 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, backpressure is an integral part of this model in order to allow the queues which mediate between threads to be bounded. The benefits of asynchronous processing would be negated if the backpressure signals were synchronous (see also the Reactive Manifesto), therefore care has been taken to mandate fully non-blocking and asynchronous behavior of all aspects of a Reactive Streams implementation. It is the intention of this specification to allow the creation of many conforming implementations, which by virtue of abiding by the rules will be able to interoperate smoothly, preserving the aforementioned benefits and characteristics across the whole processing graph of a stream application. It should be noted that the precise nature of stream manipulations (transformation, splitting, merging, etc.) is not covered by this specification. Reactive Streams are only concerned with mediating the stream of data between different API Components. In their development care has been taken to ensure that all basic ways of combining streams can be expressed. In summary, Reactive Streams is a standard and specification for Stream-oriented libraries for the JVM that• process a potentially unbounded number of elements• in sequence,• asynchronously passing elements between components,• with mandatory non-blocking backpressure. The Reactive Streams specification consists of the following parts: ***The API*** specifies the types to implement Reactive Streams and achieve interoperability between different implementations. ***The Technology Compatibility Kit (TCK)*** is a standard test suite for conformance testing of implementations. Implementations are free to implement additional features not covered by the specification as long as they conform to the API requirements and pass the tests in the TCK. API Components ### The API consists of the following components that are required to be provided by Reactive Stream implementations:• Publisher• Subscriber• Subscription• Processor A *Publisher* is a provider of a potentially unbounded number of sequenced elements, publishing them according to the demand received from its Subscriber(s). In response to a call to the possible invocation sequences for methods on the are given by the following protocol: This means that is always signalled, followed by a possibly unbounded number of signals (as requested by ) followed by an signal if there is a failure, or an signal when no more elements are available—all as long as the is not cancelled. NOTES• The specifications below use binding words in capital letters from https://www.ietf.org/rfc/rfc2119.txt Glossary | Term | Definition | | ------------------------- | ------------------------------------------------------------------------------------------------------ | | Signal | As a noun: one of the , , , , or methods. As a verb: calling/invoking a signal. | | Demand | As a noun, the aggregated number of elements requested by a Subscriber which is yet to be delivered (fulfilled) by the Publisher. As a verb, the act of -ing more elements. | | Synchronous(ly) | Executes on the calling Thread. | | Return normally | Only ever returns a value of the declared type to the caller. The only legal way to signal failure to a is via the method.| | Responsivity | Readiness/ability to respond. In this document used to indicate that the different components should not impair each others ability to respond. | | Non-obstructing | Quality describing a method which is as quick to execute as possible—on the calling thread. This means, for example, avoids heavy computations and other things that would stall the caller´s thread of execution. | | Terminal state | For a Publisher: When or has been signalled. For a Subscriber: When an or has been received.| | NOP | Execution that has no detectable effect to the calling thread, and can as such safely be called any number of times.| | Serial(ly) | In the context of a Signal, non-overlapping. In the context of the JVM, calls to methods on an object are serial if and only if there is a happens-before relationship between those calls (implying also that the calls do not overlap). When the calls are performed asynchronously, coordination to establish the happens-before relationship is to be implemented using techniques such as, but not limited to, atomics, monitors, or locks. | | Thread-safe | Can be safely invoked synchronously, or asychronously, without requiring external synchronization to ensure program correctness. | SPECIFICATION• Publisher (Code) onNext Publisher Subscriber Subscriber Subscription Publisher onNext Subscription onComplete onError onSubscribe onNext onError onComplete Subscriber Publisher onError Publisher onComplete Publisher onError onComplete Subscriber Subscriber Subscription onError onComplete Subscription Subscriber Publisher.subscribe onSubscribe Subscriber Subscriber Subscriber null java.lang.NullPointerException Subscriber onError onSubscribe onSubscribe onSubscribe Subscriber null java.lang.NullPointerException Publisher.subscr…