转载

RxJava(十一)：并行编程

博客主页

1. RxJava 并行操作

被观察者（ Observable/Flowable/Single/Completable/May ）发射的数据流可以经历各种线程切换，但是数据流的各个元素之间不会产生并行执行的效果。井行不是并发，也不是同步，更不是异步。

并发（ concurrency ）是指一个处理器同时处理多个任务。并行（ parallelism ）是多个处理器

或者是多核的处理器同时处理多个不同的任务。井行是同时发生的多个并发事件，具有井发的含义，而并发则不一定是并行。

1.1 借助 flatMap 实现并行

在 RxJava 中可以借助 flatMap 操作符来实现

Observable.range(1, 100)
        .flatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                return Observable.just(integer)
                        .subscribeOn(Schedulers.computation())
                        .map(new Function<Integer, String>() {
                            @Override
                            public String apply(Integer integer) throws Exception {
                                return integer.toString();
                            }
                        });
            }
        })
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, "Next: " + s);
            }
        });

flatMap 操作符的原理是将这个 Observable 转化为为多个以原 Observable 发射的数据作为源数据 Observable，然后再将这多个 Observable 发射的数据整合发射出来。最后的顺序可能会交错地发射出来。

flatMap 会对原始 Observable 发射的每一项数据执行变换操作。在这里，生成的每个 Observable 使用线程池（指定了 computation 作为 Scheduler ）并发地执行。

还可以使用 ExecutorService 来创建一个 Scheduler 对刚才的代码稍微做一些改动。

int threadNum = Runtime.getRuntime().availableProcessors() + 1;

final ExecutorService executorService = Executors.newFixedThreadPool(threadNum);

final Scheduler scheduler = Schedulers.from(executorService);

Observable.range(1, 100)
        .flatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                return Observable.just(integer)
                        .subscribeOn(scheduler)
                        .map(new Function<Integer, String>() {
                            @Override
                            public String apply(Integer integer) throws Exception {
                                return integer.toString();
                            }
                        });
            }
        })
        .doFinally(new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "Finally.");
                executorService.shutdown();
            }
        })
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, "Next: " + s);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.d(TAG, "Error.");
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "Complete.");
            }
        });

当完成所有的操作之后， executorService 需要执行 shutdown() 来关闭 ExecutorService。我们可以使用 doFinally 操作符来执行 shutdown()。

doFinally 操作符可以在 onError 或者 onComplete 之后调用指定的操作，或由下游处理。

1.2 通过 Round-Robin 算法实现并行

Round-Robin 算法是最简单的一种负载均衡算法。它的原理是把来自用户的请求轮流分配给内部的服务器：从服务器 1 开始，直到服务器 N、，然后重新开始循环，也被称为啥希取模法，是非常常用的数据分片方法。 Round-Robin 算法的优点是简洁，它无须记录当前所有连接的状态，所以是一种无状态调度。

通过 Round-Robin 算法把数据按线程数分组，例如分成 5 组，每组个数相同，一起发送处理。这样做的目的是可以减少 Observable 的创建，从而节省系统资源，但是会增加处理时间。Round-Robin 算法可以看成是对时间和空间的综合考虑。

final AtomicInteger batch = new AtomicInteger(0);

Observable.range(1, 100)
        .groupBy(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                return batch.getAndIncrement() % 5;
            }
        })
        .flatMap(new Function<GroupedObservable<Integer, Integer>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(GroupedObservable<Integer, Integer> integerIntegerGroupedObservable) throws Exception {
                return integerIntegerGroupedObservable.observeOn(Schedulers.io())
                        .map(new Function<Integer, String>() {
                            @Override
                            public String apply(Integer integer) throws Exception {
                                return integer.toString();
                            }
                        });
            }
        })
        .subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                Log.d(TAG, "Next: " + o);
            }
        });

2. ParallelFlowable

2.1 ParallelFlowable 介绍

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

public abstract class ParallelFlowable<T> { }

ParallelFlowable 是并行的 Flowable 版本，并不是新增的被观察者类型。在 ParallelFlowable 中，很多典型的操作符（ take、skip 等）是不可用的。

在 RxJava 并没有 ParallelObservable ，因为在 RxJava 2.x 之后， Observable 不再支持背压。

然而在并行处理中背压是必不可少的，否则会淹没在并行操作符的内部队列中。

也不存在 ParallelSingle、ParallelCompletable、ParallelMaybe

2.1.1 ParallelFlowable 实现并行

在相应的操作符上调用 Flowable 的 parallel() 就会返回 ParallelFlowable

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

parallelFlowable
        .runOn(Schedulers.io())
        .map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return integer.toString();
            }
        })
        .sequential()
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, "Next: " + s);
            }
        });

其中 parallel() 调用了 ParallelFlowable.from

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

public static <T> ParallelFlowable<T> from(@NonNull Publisher<? extends T> source) {
    return from(source, Runtime.getRuntime().availableProcessors(), Flowable.bufferSize());
}

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

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

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

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

如果己经使用了必要的井行操作，则可以通过 ParallelFlowable.sequential() 操作符返回到顺序流。

2.1.2 ParallelFlowable 与 Scheduler

ParallelFlowable 遵循与 Flowable 相同的异步原理，因此 parallel() 本身并不引入顺序源的异

步消耗，只准备并行流，但是可以通过 runOn(Scheduler) 操作符定义异步。这点与 Flowable

很大不同， Flowable 使用 subscribeOn, observeOn 操作符。

runOn() 可以指定 prefetch 的数量。

public final ParallelFlowable<T> runOn(@NonNull Scheduler scheduler) {
    return runOn(scheduler, Flowable.bufferSize());
}

public final ParallelFlowable<T> runOn(@NonNull Scheduler scheduler, int prefetch) {
    ObjectHelper.requireNonNull(scheduler, "scheduler");
    ObjectHelper.verifyPositive(prefetch, "prefetch");
    return RxJavaPlugins.onAssembly(new ParallelRunOn<T>(this, scheduler, prefetch));
}

2.2 ParallelFlowable 的操作符

并非所有的顺序操作在并行世界中都是有意义的。目前 ParallelFlowable 只支持如下操作

map, filter, flatMap, concatMap, reduce, collect, sorted, toSortedList, compose，fromArray, doOnCancel, doOnError, doOnComplete, doOnNext, doAfterNext, doOnSubscribe, doAfterTerminated, doOnRequest

这些 ParallelFlowable 可用的操作符，使用方法与 Flowable 中的用法