RxJava 之 ParallelFlowable

parallelflowable.sequential.png

一. ParallelFlowable

1.1 ParallelFlowable介绍

RxJava 2.0.5 版本新增了 ParallelFlowable API，它允许并行地执行一些运算符，譬如map、filter、concatMap、flatMap、collect、reduce等。

/**
 * Abstract base class for Parallel publishers that take an array of Subscribers.
 * 

 * Use {@code from()} to start processing a regular Publisher in 'rails'.
 * Use {@code runOn()} to introduce where each 'rail' should run on thread-vise.
 * Use {@code sequential()} to merge the sources back into a single Flowable.
 *
 * 
History: 2.0.5 - experimental
 * @param  the value type
 * @since 2.1 - beta
 */
@Beta
public abstract class ParallelFlowable {
   ...
}

ParallelFlowable是并行的Flowable版本，并不是新增的被观察者类型。在ParallelFlowable中很多典型的运算符(如take, skip等等)是不可用的。

在RxJava中没有ParallelObservable，因为在RxJava 2之后Observable不再支持背压。然而在并行处理中背压是必不可少的，否则会淹没在并行运算符的内部队列中。正是因为数据的处理在一个线程上比较缓慢，所以我们才会使用并行。

同理，也没有ParallelSingle、ParallelCompletable以及ParallelMaybe。

1.2 ParallelFlowable实现并行

类似Java 8的并行流，在相应的操作符上调用Flowable的parallel()就会返回ParallelFlowable。

        ParallelFlowable parallelFlowable = Flowable.range(1,100).parallel();

        parallelFlowable
                .runOn(Schedulers.io())
                .map(new Function() {

                    @Override
                    public Object apply(@NonNull Integer integer) throws Exception {
                        return integer.toString();
                    }
                })
                .sequential()
                .subscribe(new Consumer() {
                    @Override
                    public void accept(@NonNull String str) throws Exception {
                        System.out.println(str);
                    }
                });

其中，parallel()调用了ParallelFlowable.from(@NonNull Publisher source)

    public final ParallelFlowable parallel() {
        return ParallelFlowable.from(this);
    }

ParallelFlowable的from()方法，通过Publisher并以循环的方式在多个“轨道”（CPU数）上消费它。

    /**
     * Take a Publisher and prepare to consume it on multiple 'rails' (number of CPUs)
     * in a round-robin fashion.
     * @param  the value type
     * @param source the source Publisher
     * @return the ParallelFlowable instance
     */
    @CheckReturnValue
    public static  ParallelFlowable from(@NonNull Publisher source) {
        return from(source, Runtime.getRuntime().availableProcessors(), Flowable.bufferSize());
    }

在默认情况下，并行级别被设置为可用CPU的数量(Runtime.getRuntime().availableProcessors())，并且顺序源的预取量设置为Flowable.bufferSize()。 两者都可以通过重载parallel()来指定。

    public final ParallelFlowable parallel(int parallelism) {
        ObjectHelper.verifyPositive(parallelism, "parallelism");
        return ParallelFlowable.from(this, parallelism);
    }

    public final ParallelFlowable parallel(int parallelism, int prefetch) {
        ObjectHelper.verifyPositive(parallelism, "parallelism");
        ObjectHelper.verifyPositive(prefetch, "prefetch");
        return ParallelFlowable.from(this, parallelism, prefetch);
    }

在最后，如果已经使用了必要的并行操作，您可以通过ParallelFlowable.sequential()操作符返回到顺序流。

parallelFlowable
                ......
                .sequential()
                .subscribe(new Consumer