博客主页
1. RxJava 并行操作
被观察者( Observable/Flowable/Single/Completable/May )发射的数据流可以经历各种线程切换,但是数据流的各个元素之间不会产生并行执行的效果。井行不是并发,也不是同步,更不是异步。
并发( concurrency )是指一个处理器同时处理多个任务。并行( parallelism )是多个处理器
或者是多核的处理器同时处理多个不同的任务。井行是同时发生的多个并发事件,具有井发的含义,而并发则不一定是并行。
1.1 借助 flatMap 实现并行
在 RxJava 中可以借助 flatMap 操作符来实现
Observable.range(1, 100)
.flatMap(new Function>() {
@Override
public ObservableSource apply(Integer integer) throws Exception {
return Observable.just(integer)
.subscribeOn(Schedulers.computation())
.map(new Function() {
@Override
public String apply(Integer integer) throws Exception {
return integer.toString();
}
});
}
})
.subscribe(new Consumer() {
@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>() {
@Override
public ObservableSource apply(Integer integer) throws Exception {
return Observable.just(integer)
.subscribeOn(scheduler)
.map(new Function() {
@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() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, "Next: " + s);
}
}, new Consumer() {
@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() {
@Override
public Integer apply(Integer integer) throws Exception {
return batch.getAndIncrement() % 5;
}
})
.flatMap(new Function, ObservableSource>() {
@Override
public ObservableSource apply(GroupedObservable integerIntegerGroupedObservable) throws Exception {
return integerIntegerGroupedObservable.observeOn(Schedulers.io())
.map(new Function() {
@Override
public String apply(Integer integer) throws Exception {
return integer.toString();
}
});
}
})
.subscribe(new Consumer