Thanks for using RxJava but before you post an issue, please consider the following points:

- [ ] If you think you found a bug, please include a code sample that reproduces the problem. Dumping a stacktrace is usually not enough for us.

- [ ] If you have a question/issue about a library/technology built on top of RxJava (such as Retrofit, RxNetty, etc.), please consider asking a question on StackOverflow first (then maybe on their issue list).

When submitting code, please make every effort to follow existing conventions and style in order to keep the code as readable as possible.

All files are released with the Apache 2.0 license.

Its intended audience is the implementers of the library.

- `Observable` (RxJS, Rx.Net, RxJava v1.x without backpressure, RxJava v2).

- Callbacks (the producer calls the function at its convenience).

- IRQ, mouse events, IO interrupts.

- Reactive Streams `Publisher` (with `request(n)` credit always granted faster or in larger quantity than producer).

- Java 9 `Flow.Publisher` (with `request(n)` credit always granted faster than or in larger quantity than producer).

Examples:

- `Iterable`.

- Reactive Streams `Publisher` (without concurrency, producer and consumer on the same thread).

- Java 9 `Flow.Publisher` (without concurrency, producer and consumer on the same thread).

- `Future` & `Promise`.

- `Single` (lazy `Future`).

- Reactive Streams `Publisher`.

- Java 9 `Flow.Publisher`.

- 1.x `Observable` (with backpressure).

- `AsyncEnumerable`/`AsyncIterable`.

Instead of the indirection of an `onSubscribe` and `lift`, operators are to be implemented by extending the base classes. For example, the `map`

operator will look like this:

For performance, the mode is an integer bitflags setup, called early during subscription time, and allows negotiating the fusion mode. Usually, producers can do only one mode and consumers can do both mode. Because fused, intermediate operators attach logic (which is many times user-callback) to the exit point of the queue interface (poll()), it may change the computation location of those callbacks in an unwanted way. The flag `BOUNDARY` is added by consumers indicating that they will consume the queue over an async boundary. Intermediate operators, such as `map` and `filter` then can reject the fusion in such sequences.

- `poll()`.

- `isEmpty()`.

RxJava is a Java VM implementation of [Reactive Extensions](https://reactivex.io): a library for composing asynchronous and event-based programs by using observable sequences.

It extends the [observer pattern](https://en.wikipedia.org/wiki/Observer_pattern) to support sequences of data/events and adds operators that allow you to compose sequences together declaratively while abstracting away concerns about things like low-level threading, synchronization, thread-safety and concurrent data structures.

- single dependency: [Reactive-Streams](https://github.com/reactive-streams/reactive-streams-jvm)

- continued support for Java 6+ & [Android](https://github.com/ReactiveX/RxAndroid) 2.3+

- Java 8 lambda-friendly API

- async or synchronous execution

- virtual time and schedulers for parameterized concurrency

)

- `Schedulers.computation()`: Run computation intensive work on a fixed number of dedicated threads in the background. Most asynchronous operator use this as their default `Scheduler`.

- `Schedulers.io()`: Run I/O-like or blocking operations on a dynamically changing set of threads.

| Type | Class | Interface | Consumer |

|------|-------|-----------|----------|

- [Wiki](https://github.com/ReactiveX/RxJava/wiki)

Example for Gradle:

and for Maven:

<dependency>

<artifactId>rxjava</artifactId>

<version>x.y.z</version>

</dependency>

and for Ivy:

See the License for the specific language governing permissions and

limitations under the License.