Backpressure and Flowables
Backpressure is only needed in multi-threading situations with a large number of emissions. When the rx call chain is all executed on one thread, the thread will take each emission one at a time all the way through the chain from the source observable to the final observer. When the chain is executed across multiple threads, then the first thread will take an emission through the chain to the hand off point and hand it off to the next thread, and then immediately get the next emission and move it through.If the second thread is slower at moving emissions through its part of the call chain, then the number of emissions that the first thread has finished but the second thread has yet to start can pile up. If the total number of emissions is small, then this isn't really an issue, but with a large number of emissions this pile up could potentially lead to an out of memory error. This is where backpressure and Flowables come in.
Essentially, using a Flowable in this example is telling thread one to slow down. It would do this by having thread one process a certain number of emissions at the start, and then wait until thread two has pulled through a certain percentage of those emissions before processing more. In this way, it tries to keep a small buffer of emissions between the two threads without letting it get out of control, thus keeping thread 2 busy without pause, but without overloading memory with thread one going nonstop.
Note that Flowable does add overhead, so opt for Observable in cases where backpressure isn't needed, but when it is needed, simply switching Observable to Flowable should be sufficient in most cases. Though there are a handful of exceptions.
Since dealing with these exceptions is infrequent, I don't feel the need to go into detail here, but if you do run into such a situation, there are a number of options available, depending on the situation, varying from using an onBackpressureXXX() operator to creating your own custom Flowable.
