RxJava 并行操做

时间 2019-11-16

标签 rxjava 并行栏目 Java 繁體版

原文原文链接

上一篇文章RxJava 线程模型分析详细介绍了RxJava的线程模型，被观察者(Observable、Flowable...)发射的数据流能够经历各类线程切换，可是数据流的各个元素之间不会产生并行执行的效果。咱们知道并行并非并发，不是同步，更不是异步。java

Java 8新增了并行流来实现并行的效果，只须要在集合上调用parallelStream()便可。算法

List<Integer> result = new ArrayList();
        for(Integer i=1;i<=100;i++) {

            result.add(i);
        }

        result.parallelStream()
                .map(new java.util.function.Function<Integer, String>() {


            @Override
            public String apply(Integer integer) {
                return integer.toString();
            }
        }).forEach(new java.util.function.Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });复制代码

若是要达到相似于 Java8 的 parallel 执行效果，能够借助 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 str) throws Exception {

                        System.out.println(str);
                    }
                });复制代码

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

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

固然咱们还可使用ExecutorService来建立一个Scheduler。负载均衡

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

        ExecutorService executor = Executors.newFixedThreadPool(threadNum);
        final Scheduler scheduler = Schedulers.from(executor);
        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();
                                    }
                                });
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String str) throws Exception {

                        System.out.println(str);
                    }
                });复制代码

须要补充的是：当完成全部的操做以后，ExecutorService须要执行shutdown()来关闭 ExecutorService。在这里，可使用doFinally操做符来执行shutdown()。异步

doFinally操做符能够在onError或者onComplete以后调用指定的操做，或由下游处理。ide

增长了doFinally操做符以后，代码是这样的。post

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

        final ExecutorService executor = Executors.newFixedThreadPool(threadNum);
        final Scheduler scheduler = Schedulers.from(executor);
        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 {
                        executor.shutdown();
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String str) throws Exception {

                        System.out.println(str);
                    }
                });复制代码

Round-Robin 算法实现并行spa

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(@NonNull Integer integer) throws Exception {
                        return batch.getAndIncrement() % 5;
                    }
                })
                .flatMap(new Function<GroupedObservable<Integer, Integer>, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(@NonNull GroupedObservable<Integer, Integer> integerIntegerGroupedObservable) throws Exception {
                        return integerIntegerGroupedObservable.observeOn(Schedulers.io())
                                .map(new Function<Integer, String>() {

                                    @Override
                                    public String apply(@NonNull Integer integer) throws Exception {
                                        return integer.toString();
                                    }
                                });
                    }
                })
                .subscribe(new Consumer<Object>() {
                    @Override
                    public void accept(@NonNull Object o) throws Exception {
                        System.out.println(o);
                    }
                });复制代码

在这里，也可使用ExecutorService建立Scheduler，来替代Schedulers.io()

final AtomicInteger batch = new AtomicInteger(0);

        int threadNum = 5;

        final ExecutorService executor = Executors.newFixedThreadPool(threadNum);
        final Scheduler scheduler = Schedulers.from(executor);

        Observable.range(1,100)
                .groupBy(new Function<Integer, Integer>() {
                    @Override
                    public Integer apply(@NonNull Integer integer) throws Exception {
                        return batch.getAndIncrement() % threadNum;
                    }
                })
                .flatMap(new Function<GroupedObservable<Integer, Integer>, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(@NonNull GroupedObservable<Integer, Integer> integerIntegerGroupedObservable) throws Exception {
                        return integerIntegerGroupedObservable.observeOn(scheduler)
                                .map(new Function<Integer, String>() {

                                    @Override
                                    public String apply(@NonNull Integer integer) throws Exception {
                                        return integer.toString();
                                    }
                                });
                    }
                })
                .subscribe(new Consumer<Object>() {
                    @Override
                    public void accept(@NonNull Object o) throws Exception {
                        System.out.println(o);
                    }
                });复制代码