小栗子

Observable.just(1)
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                // 1
            }

            @Override
            public void onNext(Integer integer) {
                // 2
            }

            @Override
            public void onError(Throwable e) {
                // 3
            }

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

Just源码解析

Observable#just

public static <T> Observable<T> just(T item) {
    ObjectHelper.requireNonNull(item, "item is null");
    return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));
}

返回一个ObservableJust对象

RxJavaPlugins#onAssembly

public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
    Function<? super Observable, ? extends Observable> f = onObservableAssembly;
    if (f != null) {
        return apply(f, source);
    }
    return source;
}

onObservableAssembly默认为空，返回我们传入的source

Observable#subscribe

public final void subscribe(Observer<? super T> observer) {
    ...
    subscribeActual(observer);
    ... 
}

调用了subscribeActual，抽象方法。

ObservableJust#subscribeActual

@Override
protected void subscribeActual(Observer<? super T> observer) {
    ScalarDisposable<T> sd = new ScalarDisposable<T>(observer, value);
    observer.onSubscribe(sd);
    sd.run();
}

首先执行了onSubscribe方法。

ScalarDisposable

public static final class ScalarDisposable<T>
extends AtomicInteger
implements QueueDisposable<T>, Runnable {
    ...
    @Override
    public void run() {
        if (get() == START && compareAndSet(START, ON_NEXT)) {
            observer.onNext(value);
            if (get() == ON_NEXT) {
                lazySet(ON_COMPLETE);
                observer.onComplete();
            }
        }
    }
    ...
}

让我们忽略AtomicInteger相关知识。

run方法中先调用了onNext，然后调用了onComplete，onError是执行不到的，执行结束。

总结

同步使用时，按照onSubscribe，onNext，onComplete或onError的顺序执行。