public void hystrix(String username){

    /**
     * R call();
     */
    Func0<Observable<Object>> defer = new Func0<Observable<Object>>(){
        @Override
        public Observable<Object> call() {
            System.out.println("4.username = " + username);
            return Observable.just(2);
        }
    };
    /**
     * R call(T t);
     */
    Func1<Object,Object> map = new Func1<Object,Object>(){

        @Override
        public Object call(Object observable) {
            System.out.println("5.username = " + username);
            if(observable instanceof Integer){
                return ((Integer) observable)* 3;
            }
            return null;
        }
    };

    Observable.defer(new Func0<Observable<Object>>() {
        @Override
        public Observable<Object> call() {
            System.out.println("1.username = " + username);
            return Observable.defer(new Func0<Observable<Object>>() {

                @Override
                public Observable<Object> call() {
                    return Observable.just((Object) 12).doOnTerminate(new Action0() {
                        @Override
                        public void call() {
                            System.out.println("this is doOnTerminate1");
                        }
                    });
                }
            }).doOnTerminate(new Action0() {
                @Override
                public void call() {
                    System.out.println("this is doOnTerminate2");
                }
            }).doOnCompleted(new Action0() {
                @Override
                public void call() {
                    System.out.println("this is doOnCompleted");
                }
            });
        }
    }).doOnTerminate(new Action0() {
        @Override
        public void call() {
            System.out.println("this is doOnTerminate3");
        }
    }).subscribe(new Subscriber<Object>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Object o) {
            System.out.println("this is onNext o = " + o);
        }
    });
}

1.username = ceshi
this is onNext o = 12
this is doOnTerminate1
this is doOnTerminate2
this is doOnCompleted
this is doOnTerminate3

1、OnSubscribeDoOnEach

public final Observable<T> doOnTerminate(final Action0 onTerminate) {
    Action1<T> onNext = Actions.empty();
    Action1<Throwable> onError = Actions.toAction1(onTerminate);

    Observer<T> observer = new ActionObserver<T>(onNext, onError, onTerminate);

    return unsafeCreate(new OnSubscribeDoOnEach<T>(this, observer));
}

public OnSubscribeDoOnEach(Observable<T> source, Observer<? super T> doOnEachObserver) {
    this.source = source;
    this.doOnEachObserver = doOnEachObserver;
}

2、DoOnEachSubscriber

private static final class DoOnEachSubscriber<T> extends Subscriber<T> {

    private final Subscriber<? super T> subscriber;
    private final Observer<? super T> doOnEachObserver;

    private boolean done;

    DoOnEachSubscriber(Subscriber<? super T> subscriber, Observer<? super T> doOnEachObserver) {
        super(subscriber);
        this.subscriber = subscriber;
        this.doOnEachObserver = doOnEachObserver;
    }

    @Override
    public void onCompleted() {
        if (done) {
            return;
        }
        try {
            //doOnTerminate、doOnCompleted都会此处执行，同时存在前提下谁在前谁优先执行
            doOnEachObserver.onCompleted();
        } catch (Throwable e) {
            Exceptions.throwOrReport(e, this);
            return;
        }
        // Set `done` here so that the error in `doOnEachObserver.onCompleted()` can be noticed by observer
        done = true;
        subscriber.onCompleted();
    }

    @Override
    public void onError(Throwable e) {
        if (done) {
            RxJavaHooks.onError(e);
            return;
        }
        done = true;
        try {
            doOnEachObserver.onError(e);
        } catch (Throwable e2) {
            Exceptions.throwIfFatal(e2);
            subscriber.onError(new CompositeException(Arrays.asList(e, e2)));
            return;
        }
        subscriber.onError(e);
    }

    @Override
    public void onNext(T value) {
        if (done) {
            return;
        }
        try {
            doOnEachObserver.onNext(value);
        } catch (Throwable e) {
            Exceptions.throwOrReport(e, this, value);
            return;
        }
        subscriber.onNext(value);
    }
}

总结：一个被观察者Observable中可能包含多个被观察者Observable，不同Observable有理到外顺序执行。具体Observable存在多个操作符，则根据其操作符功能控制不同操作符执行顺序。