Rxjava2 doAfterTerminate

doAfterTerminate的作用就是终止发送时候调用。

 Observable.fromArray("1", "2", "3").doAfterTerminate(new Action() {
            @Override
            public void run() throws Exception {
                System.out.println("doAfterTerminate");
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                System.out.println("subscribe: " + s);
            }
        });

输出

subscribe: 1
subscribe: 2
subscribe: 3
doAfterTerminate

看看源码

   public final Observable<T> doAfterTerminate(Action onFinally) {
        ...
        return doOnEach(Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.EMPTY_ACTION, onFinally);
    }
    
  private Observable<T> doOnEach(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate) {
       ...
        return RxJavaPlugins.onAssembly(new ObservableDoOnEach<T>(this, onNext, onError, onComplete, onAfterTerminate));
    }   

当调用onComplete或者onError时，数据流就可以终止了，都会在最后调用 onAfterTerminate.run();

public void onError(Throwable t) {
            if (done) {
                RxJavaPlugins.onError(t);
                return;
            }
            done = true;
            try {
                onError.accept(t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                t = new CompositeException(t, e);
            }
            downstream.onError(t);

            try {
                onAfterTerminate.run();
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                RxJavaPlugins.onError(e);
            }
        }

        @Override
        public void onComplete() {
            if (done) {
                return;
            }
            try {
                onComplete.run();
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                onError(e);
                return;
            }

            done = true;
            downstream.onComplete();

            try {
                onAfterTerminate.run();
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                RxJavaPlugins.onError(e);
            }
        }

但是一旦调用dispose，就不会调用doAfterTerminate了，

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NotNull ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("1");
                mDisposable.dispose();
            }
        }).doAfterTerminate(new Action() {
            @Override
            public void run() throws Exception {
                //因为 mDisposable.dispose(); 就不会执行println了
                System.out.println("doAfterTerminate");
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NotNull Disposable d) {
                System.out.println("onSubscribe");
                mDisposable = d;
            }

            @Override
            public void onNext(@NotNull String s) {
                System.out.println("onNext " + s);
            }

            @Override
            public void onError(@NotNull Throwable e) {
                System.out.println("onError");
            }

            @Override
            public void onComplete() {
                System.out.println("onComplete");
            }
        });