Android解决方案之：串行任务和并行任务的处理

简介

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

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

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

串行: FlatMap

TestApis testApis = RetrofitManager.getInstance().createApi(TestApis.class);
        testApis.getTangShiSongCi() // 先访问唐诗宋词接口
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .flatMap(new Function<TSSCRes<TSSCResult>, ObservableSource<XHYRes<XHYResult>>>() {
                    @Override
                    public ObservableSource<XHYRes<XHYResult>> apply(TSSCRes<TSSCResult> listTSSCRes) throws Exception {
                        if (listTSSCRes != null && listTSSCRes.getResult() != null) {
                            return testApis.getXHY();  // 再访问歇后语接口
                        } else {
                            return null;
                        }
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new BaseObserver<XHYRes<XHYResult>>() {

                               @Override
                               public void onError(ApiException exception) {
                                   LogUtil.e(TAG, "error:" + exception.getMessage());
                               }

                               @Override
                               public void onSuccess(XHYRes<XHYResult> testBeans) {
                                   LogUtil.i(TAG, testBeans.toString());
                               }
                           }
                );

FlatMap是变换操作符，先处理第一个请求getTangShiSongCi()，再发送下一个getXHY()。

串行: Concat

TestApis testApis = RetrofitManager.getInstance().createApi(TestApis.class);
        Observable<TSSCRes<TSSCResult>> o1 = testApis.getTangShiSongCi();
        Observable<XHYRes<XHYResult>> o2 = testApis.getXHY();
        Observable
                .concat(o1, o2) // 依次处理, 先处理o1, 再处理o2
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .subscribe(new BaseObserver<Object>() {

                               @Override
                               public void onError(ApiException exception) {
                                   LogUtil.e(TAG, "error:" + exception.getMessage());
                               }

                               @Override
                               public void onSuccess(Object object) {
                                   if (object instanceof TSSCRes) {
                                       LogUtil.i(TAG, object.toString());
                                   } else if (object instanceof XHYRes) {
                                       LogUtil.i(TAG, object.toString());
                                   }
                               }
                           }
                );

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

并行: Merge

TestApis testApis = RetrofitManager.getInstance().createApi(TestApis.class);
        Observable<TSSCRes<TSSCResult>> o1 = testApis.getTangShiSongCi();
        Observable<XHYRes<XHYResult>> o2 = testApis.getXHY();
        Observable
                .merge(o1, o2)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .subscribe(new BaseObserver<Object>() {

                               @Override
                               public void onError(ApiException exception) {
                                   LogUtil.e(TAG, "error:" + exception.getMessage());
                               }

                               @Override
                               public void onSuccess(Object object) {
                                   if (object instanceof TSSCRes) {
                                       LogUtil.i(TAG, object.toString());
                                   } else if (object instanceof XHYRes) {
                                       LogUtil.i(TAG, object.toString());
                                   }
                               }
                           }
                );

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

并行: Zip

TestApis testApis = RetrofitManager.getInstance().createApi(TestApis.class);
        Observable<TSSCRes<TSSCResult>> o1 = testApis.getTangShiSongCi();
        Observable<XHYRes<XHYResult>> o2 = testApis.getXHY();
        Observable.zip(o1, o2, new BiFunction<TSSCRes<TSSCResult>, XHYRes<XHYResult>, Integer>() {
            @Override
            public Integer apply(TSSCRes<TSSCResult> tsscRes, XHYRes<XHYResult> xhyRes) throws Exception {
                return tsscRes.getResult().size() + xhyRes.getResult().size();
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .subscribe(new BaseObserver<Integer>() {

                               @Override
                               public void onError(ApiException exception) {
                                   LogUtil.e(TAG, "error:" + exception.getMessage());
                               }

                               @Override
                               public void onSuccess(Integer count) {
                                   LogUtil.e(TAG, "count = " + count);
                               }
                           }
                );

Zip会跟merge一样，也会将两个Observable同时发送，只是在处理结果的时候会将两个发送源的结果一并返回。

github地址

https://github.com/ddnosh/AndroidQuick