RxJava实现串行任务和并行任务

简介

串行和并行，是针对任务这个概念而来的，也就是串行任务和并行任务。
那我们需要了解一下什么是任务。

以一个http网络请求来看，这一个网络请求就是一个任务。它包含了发送请求、后台处理、处理返回数据这几个步骤。

我们的需求就是多个任务的集合。有些需求是需要任务之间依次执行的，也就是下一个任务是需要基于上一个任务的处理结果才能执行的，这样的任务需求我们称之为串行任务；而有些需求是要求执行多个任务的，而且任务之间也并无依赖关系，这样的任务需求我们称之为并行任务。
接下来我们通过RxJava的操作符实例来展示一下串行和并行任务的实现。

串行: FlatMap

Observable<String> o1 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) {
                try {
                    Thread.sleep(1000); // 假设此处是耗时操作
                } catch (Exception ee) {
                    ee.printStackTrace();
                }
                e.onNext("1");
                e.onComplete();
            }
        });

        Observable<String> o2 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) {
                try {
                    Thread.sleep(1000); // 假设此处是耗时操作
                } catch (Exception ee) {
                    ee.printStackTrace();
                }
                e.onNext("2");
                e.onComplete();
            }
        });
        
        o1.flatMap(new Function<String, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(String s) throws Exception {
                return o2;
            }
        })
                .observeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String s) {
                        
                    }

                    @Override
                    public void onError(Throwable e) {
                        
                    }

                    @Override
                    public void onComplete() {

                    }
                });

FlatMap是变换操作符，先处理第一个请求o1，再发送下一个o2。

串行: Concat

Observable.concat(o1, o2)
                .compose(RxUtil.applySchedulers())
                .compose(lifecycleProvider.bindUntilEvent(Lifecycle.Event.ON_DESTROY))
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }

                    @Override
                    public void onNext(String s) {
                        Log.d(TAG, s);
                        if ("1".equals(s)) {
                            ToastUtil.showToast("concat: 1");
                        } else if ("2".equals(s)) {
                            ToastUtil.showToast("concat: 2");
                        } 
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onComplete() {
                    }
                });

Concat是一个聚合操作符，我们看到有两个Observable：o1和o2，将它们通过concat聚合在一起，系统会先处理o1，然后再处理o2，所以我们在subscribe接收的时候并不知道具体类型，所以用Object代替，在实际过程中进行类型判断。

并行: Merge

o1 = o1.subscribeOn(Schedulers.io());
o2 = o2.subscribeOn(Schedulers.io());

Observable.merge(o1, o2).compose(RxUtil.applySchedulers()).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, integer + "");
            }
        });

注意：一定要在o1和o2后面加上.subscribeOn(Schedulers.io())，否则就是串行了。

Merge是将两个Observable：o1和o2同时发送，然后再根据达到的结果进行处理，同理这边也用Object表示。

并行: Zip

Observable.zip(o1, o2, new BiFunction<String, String, String>() {
            @Override
            public String apply(String a, String b) throws Exception {
                return a + b;
            }
        }).compose(RxUtil.applySchedulers()).subscribe(new Consumer<String>() {
            @Override
            public void accept(String o) throws Exception {
                Log.d(TAG, o);
            }
        });

Zip会跟Merge一样，也会将两个Observable同时发送，只是在处理结果的时候会将两个发送源的结果一并返回。
注意：同Merge一样，Zip实现并行的话一定要在o1和o2后面加上.subscribeOn(Schedulers.io())，否则就是串行了。

github地址

https://github.com/ddnosh/AndroidQuick
找到RxJavaFragment.java文件。