RxJava（九）并行编程

RxJava的并行编程

RxJava发射的数据流虽然经过各种变换，切换线程，但并没有产生并行效果。
并行：多个处理器或多核处理器同时处理多个任务。
并发：单个处理器同时处理多个任务。
1.Java8并行流 集合上调用parallelStream

@TargetApi(24)
    private void parallelStream(){
        mList.parallelStream()
                .map(new java.util.function.Function<String, String>() {
                    @Override
                    public String apply(String s) {
                        return s.toUpperCase();
                    }
                }).forEach(new java.util.function.Consumer<String>() {
            @Override
            public void accept(String s) {
                
            }
        });
    }

2.RxJava借助FlatMap实现
FlatMap：将这个Observable转换为多个发射原始数据的Observables，并收集发射的全部数据，不保证顺序，统一发射出去。若用了自定义调度器，则需要在doFinally中关闭调度器。

3.使用Round-Robin实现负载均衡groupBy + flatMap
负载均衡：把来自用户的请求，轮流发送给服务器进行处理。此处把数据分组，然后一起发送处理，减少了Observable的创建，从而节省了系统资源。

Observable.range(1,10)
                .groupBy(new Function<Integer, String>() {      //参数：数据，键
                    @Override
                    public String apply(Integer data) {
                        //数据分成两组，偶数组键：key1，奇数组键：key2
                        return data % 2 == 0 ? "key1" : "key2";
                    }
                }).flatMap(new Function<GroupedObservable<String, Integer>, ObservableSource<String>>() {
                    //对分的两个组数据进行函数变换，最终我想返回一个发射String的Observable
            @Override
            public ObservableSource<String> apply(GroupedObservable<String, Integer> stringIntegerGroupedObservable) throws Exception {
                //对组中的每一项数据进行函数变换，返回我想要的结果String值
                return stringIntegerGroupedObservable.map(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer groupData) throws Exception {
                        return groupData.toString();
                    }
                });
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                
            }
        });

4.RxJava的ParallelFlowable实现并行
在相应的Flowable创建操作符后面调用paallel()，即可得到ParallelFlowable。

private void parallelFlowable(){
        
        ParallelFlowable parallelFlowable1 = Flowable.range(1,10).parallel();
        
        parallelFlowable1.runOn(Schedulers.io())
                .map(new Function() {
                    @Override
                    public Object apply(Object o) throws Exception {
                        return null;
                    }
                }).sequential()
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Object o) throws Exception {
                        
                    }
                });
    }

支持的操作符

//默认并行为CPU数，也可指定并行数parallelism，预取量prefetch
        ParallelFlowable parallelFlowable1 = Flowable.range(1,10).parallel(int parallelism,int prefetch);

        parallelFlowable1.as(ParallelFlowableConverter<T,R>);
        parallelFlowable1.collect(Callable, BiConsumer);
        parallelFlowable1.compose(ParallelTransformer);
        parallelFlowable1.concatMap(Function<T,R>,int prefetch);
        parallelFlowable1.concatMapDelayError(xxx);
        parallelFlowable1.doXX操作符;
        parallelFlowable1.filter(Predicate);
        parallelFlowable1.flatMap(Function<T,R>);
        parallelFlowable1.map(Function<T,R>);
        parallelFlowable1.parallelism();
        //定义异步
        parallelFlowable1.runOn(Schedulers);
        parallelFlowable1.reduce(BiFunction);
        parallelFlowable1.reduce(Callable initialSupplier,BiFunction);
        //返回到顺序流
        parallelFlowable1.sequential();
        parallelFlowable1.sequentialDelayError();
        parallelFlowable1.sorted(Comparator);
        parallelFlowable1.toSortedList(Comparator);
        parallelFlowable1.wait(long time);