RxJava 山东卷

一、考试须知

全国卷通过后，才能参加本次考试。

考试类型：开卷

作弊行为：运行源代码

二、试题 - 单项选择

rxJavaExamination1();
rxJavaExamination2();
rxJavaExamination3();

// 核心：主题多次subscribe
private void rxJavaExamination1() {
    Observable<Long> observable = Observable.interval(5, TimeUnit.MILLISECONDS)
            .take(Integer.MAX_VALUE);

    // 观察者1
    Consumer<Long> subscriber1 = new Consumer<Long>() {
        @Override
        public void accept(@NonNull Long value) throws Exception {
            Log.d(Tags.HLWANG_TAG, "观察者1 ：value ： " + value);
        }
    };

    // 观察者2
    Consumer<Long> subscriber2 = new Consumer<Long>() {
        @Override
        public void accept(@NonNull Long value) throws Exception {
            Log.d(Tags.HLWANG_TAG, "观察者2 ：value ： " + value);
        }
    };

    // 观察者1与主题建立关联
    Disposable disposable1 = observable.subscribe(subscriber1);
    try {
        Thread.sleep(100L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    // 观察者2与主题建立关联
    Disposable disposable2 = observable.subscribe(subscriber2);
    try {
        Thread.sleep(100L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    disposable1.dispose();
    disposable2.dispose();
}

// 核心：ObservablePublish
private void rxJavaExamination2() {
    Observable<Long> observable = Observable.interval(5, TimeUnit.MILLISECONDS)
            .take(Integer.MAX_VALUE);

    // 观察者3
    Consumer<Long> subscriber3 = new Consumer<Long>() {
        @Override
        public void accept(@NonNull Long value) throws Exception {
            Log.d(Tags.HLWANG_TAG, "观察者3 ：value ： " + value);
        }
    };

    // 观察者4
    Consumer<Long> subscriber4 = new Consumer<Long>() {
        @Override
        public void accept(@NonNull Long value) throws Exception {
            Log.d(Tags.HLWANG_TAG, "观察者4 ：value ： " + value);
        }
    };

    ConnectableObservable connectableObservable = observable.publish();
    connectableObservable.connect();

    // 观察者1与主题建立关联
    Disposable disposable3 = connectableObservable.subscribe(subscriber3);
    try {
        Thread.sleep(100L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    // 观察者2与主题建立关联
    Disposable disposable4 = connectableObservable.subscribe(subscriber4);
    try {
        Thread.sleep(100L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    disposable3.dispose();
    disposable4.dispose();
}

// 核心：ObservableRefCount
private void rxJavaExamination3() {
    Observable<Long> observable = Observable.interval(5, TimeUnit.MILLISECONDS)
            .take(Integer.MAX_VALUE);

    // 观察者5
    Consumer<Long> subscriber5 = new Consumer<Long>() {
        @Override
        public void accept(@NonNull Long value) throws Exception {
            Log.d(Tags.HLWANG_TAG, "观察者5 ：value ： " + value);
        }
    };

    // 观察者6
    Consumer<Long> subscriber6 = new Consumer<Long>() {
        @Override
        public void accept(@NonNull Long value) throws Exception {
            Log.d(Tags.HLWANG_TAG, "观察者6 ：value ： " + value);
        }
    };

    // 观察者7
    Consumer<Long> subscriber7 = new Consumer<Long>() {
        @Override
        public void accept(@NonNull Long value) throws Exception {
            Log.d(Tags.HLWANG_TAG, "观察者7 ：value ： " + value);
        }
    };

    // 观察者8
    Consumer<Long> subscriber8 = new Consumer<Long>() {
        @Override
        public void accept(@NonNull Long value) throws Exception {
            Log.d(Tags.HLWANG_TAG, "观察者8 ：value ： " + value);
        }
    };

    ConnectableObservable connectableObservable = observable.publish();
    connectableObservable.connect();

    observable = connectableObservable.refCount();

    // 观察者1与主题建立关联
    Disposable disposable5 = observable.subscribe(subscriber5);
    try {
        Thread.sleep(100L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    // 观察者2与主题建立关联
    Disposable disposable6 = observable.subscribe(subscriber6);
    disposable5.dispose();
    try {
        Thread.sleep(100L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    disposable6.dispose();

    Log.d(Tags.HLWANG_TAG, "-----------------------");

    // 观察者1与主题建立关联
    Disposable disposable7 = observable.subscribe(subscriber7);
    try {
        Thread.sleep(100L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    // 观察者2与主题建立关联
    Disposable disposable8 = observable.subscribe(subscriber8);
    try {
        Thread.sleep(100L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    disposable7.dispose();
    disposable8.dispose();
}

A :

观察者1与观察者2，都不是从0输出
观察者3 从0输出，观察者4不从0输出
观察者5 从0输出，观察者6 不从0输出
观察者7 从0输出，观察者8 不从0输出

B :

观察者1与观察者2，都是从0输出
观察者3 从0输出，观察者4不从0输出
观察者5 从0输出，观察者6 不从0输出
观察者7 从0输出，观察者8 不从0输出，和观察者3、4输出行为不一致

C :

观察者1与观察者2，都是从0输出
观察者3 从0输出，观察者4不从0输出
观察者5 从0输出，观察者6 不从0输出
观察者7 从0输出，观察者8 不从0输出，和观察者3、4输出行为一致

D :

观察者1与观察者2，都是从0输出
观察者3 不从0输出，观察者4不从0输出
观察者5 从0输出，观察者6 从0输出
观察者7 不从0输出，观察者8 不从0输出

E :

以上，无正确答案，我要评论正确答案