RxJava并发请求记录

看过一些关于RxJava并发的文章,终究还是自己测试一下比较心安,根据这篇博客测试几个常见的实现https://www.jianshu.com/p/6f428b52555a

首先来2个Observable备用,当然.subscribeOn(Schedulers.newThread())这个少不了,不然都在一个线程哪来的并发.

private List<Observable<String>> initObservables() {
        List<Observable<String>> obsList = new ArrayList<>();
        Observable<String> obs1 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                Log.e("TAG", "observable1：" + Thread.currentThread().getName());
                Thread.sleep(5000);
                emitter.onNext("obs1");
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.newThread());
        Observable<String> obs2 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {
                Log.e("TAG", "observable2：" + Thread.currentThread().getName());
                Thread.sleep(10000);
                emitter.onNext("obs2");
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.newThread());
        obsList.add(obs1);
        obsList.add(obs2);
        return obsList;
    }

其次再来测试下面的3个方法

merge(),concat(),zip()

private void rxMerge() {
        Observable.merge(initObservables())
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) { }

            @Override
            public void onNext(@NonNull String s) {
                Log.e("TAG","onNext"+s);
            }

            @Override
            public void onError(@NonNull Throwable e) { }

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

 merge()结果

private void rxZip() {
        List<Observable<String>> observables = initObservables();
        Observable.zip(observables.get(0), observables.get(1), new BiFunction<String, String, String>() {

            @NonNull
            @Override
            public String apply(@NonNull String s, @NonNull String s2) throws Exception {
                    return s + s2;
                }
            })
            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Observer<String>() {
                @Override
                public void onSubscribe(@NonNull Disposable d) { }

                @Override
                public void onNext(@NonNull String s) {
                    Log.e("TAG", "onNext" + s);
                }

                @Override
                public void onError(@NonNull Throwable e) { }

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

 zip()结果 

 

private void rxConcat(){
        Observable.concat(initObservables())
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) { }

                    @Override
                    public void onNext(@NonNull String s) {
                        Log.e("TAG","onNext"+s);
                    }

                    @Override
                    public void onError(@NonNull Throwable e) { }

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

concat()结果 

 

实验结论如下

/**
 * merge()可以并发
 * Observable.subscribeOn(Schedulers.newThread())
 * 谁先执行完,先返回谁的结果
 * 适合处理先来先展示的场景
 */

/**
 * zip()可以并发
 * Observable..subscribeOn(Schedulers.newThread())
 * 一起执行完,再返回结果
 * 适合处理一起展示的场景,类似Countdownlatch */

/**
 * concat()无法并发
 */

 这篇文章只记录并发的情况,串行则可以去掉.subscribeOn(Schedulers.newThread()),或者使用flatMap()已经其他api实现