最基本的使用代码：
Observable observable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter e) throws Exception {
e.onNext(1);
}
});
//转发器
observable = observable.subscribeOn(Schedulers.io());
observable = observable.observeOn(AndroidScheduler.mainThread());
//B对象，接收端
Observer observer = new Observer() {
@Override
public void onSubscribe(@NonNull Disposable d) {
//此方法在被观察者添加观察者以后就立马执行这个
Loger.e("onSubscribe----》thread" + "" + Thread.currentThread().getName());
}
@Override
public void onNext(@NonNull Integer integer) {
}
@Override
public void onError(@NonNull Throwable e) {
Loger.e("onError 和 onComplete 只能调用一个");
}
@Override
public void onComplete() {
Loger.e("onComplete 和 onError 只能调用一个");
}
@Override
public String toString() {
return "我是开始接受者";
}
};
observable.subscribe(observer);
1、创建Observable过程的变迁：
每一次的变化都是创建一个Observable对象，每一个变迁以后都是下一个Observable对象的source对象，这好比是单向链表结构。
2、执行subscribe()方法中的变化
所有的subscribe()都是在Observable中实现的，然后都调用了各自子类的subscribeActual()，因为subscribe()方法需要传入Observer对象为参数，所以执行subscribe()方法的过程中Observer都会发生变化，虽然CreateEmitter不是Observer，为了方便理解就可以这样认为。
1）执行observable.subscribe(observer);时，对应在ObservableObserveOn.subscribeActual()的代码中
@Override
protected void subscribeActual(Observer observer) {
if (scheduler instanceof TrampolineScheduler) {
source.subscribe(observer);
} else {
Scheduler.Worker w = scheduler.createWorker();
source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize));
}
}
因为scheduler是AndroidScheduler.mainThread()对象创建的ExecutorScheduler，不是属于TrampolineScheduler的子类，所以走else分支代码。首先创建了一个Scheduler.Worker对象和ObservableObserveOn.ObserveOnObserver对象，并将Scheduler.Worker对象保存在ObservableObserveOn.ObserveOnObserver对象中。
2）调用ObservableSubscribeOn.subscribeActual()，将创建的ObservableObserveOn对应的Observer对象传给上一层的ObservableSubscribeOn。
@Override
public void subscribeActual(final Observer s) {
final SubscribeOnObserver parent = new SubscribeOnObserver(s);
s.onSubscribe(parent);
parent.setDisposable(scheduler.scheduleDirect(new Runnable() {
@Override
public void run() {
source.subscribe(parent);
}
}));
}
这里也新建了一个SubscribeOnObserver类，专门属于ObservableSubscribeOn的Observer。s是ObservableObserveOn中Observer对象。对应代码是ObservableObserveOn.ObserveOnObserver类中的onSubscribe方法：
@Override
public void onSubscribe(Disposable s) {
if (DisposableHelper.validate(this.s, s)) {
this.s = s;
if (s instanceof QueueDisposable) {
@SuppressWarnings("unchecked")
QueueDisposable qd = (QueueDisposable) s;
int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);
if (m == QueueDisposable.SYNC) {
sourceMode = m;
queue = qd;
done = true;
actual.onSubscribe(this);
schedule();
return;
}
if (m == QueueDisposable.ASYNC) {
sourceMode = m;
queue = qd;
actual.onSubscribe(this);
return;
}
}
queue = new SpscLinkedArrayQueue(bufferSize);
actual.onSubscribe(this);
}
}
这里传入的s对象是ObservableSubscribeOn的Observer，不属于QueueDisposable，继续看 actual.onSubscribe(this);
actual对象是最外层用户定义的Observer对象，调用最外边的Observer的onSubscribe方法，注意一直到现在都没有进行线程的切换工作。
回到ObservableSubscribeOn的subscribeActual方法中，
parent.setDisposable(scheduler.scheduleDirect(new Runnable() {
@Override
public void run() {
source.subscribe(parent);
}
}));
这里的scheduler对象是Schedulers.io()，真身是IoScheduler，对于线程的这里不具体分析。调用线程池来执行Runnable的run方法。这时候线程已经由主线程切换成了io线程，下面的代码执行都是在io线程中。在io线程中执行 source.subscribe(parent); source是上一层的Observable对象，这里是ObservableCreate，调用ObservableCreate的subscribeActual()
3）上面已经进行了线程的切换工作，线程现在是处于io线程中，继续执行ObservableCreate的subscribeActual()方法
@Override
protected void subscribeActual(Observer observer) {
CreateEmitter parent = new CreateEmitter(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
这里首先创建了CreateEmitter对象，这里的observer对象是属于ObservableSubscribeOn的Observer对象，调用它的onSubscribe()方法：
@Override
public void onSubscribe(Disposable s) {
DisposableHelper.setOnce(this.s, s);
}
Disposable主要是为了控制线程流程的关闭工作，这里就是将整个流程保证变量一致。
接着调用source.subscribe(parent);这也是被观察者中最后的一步调用了，source对象是最开始定义的ObservableOnSubscribe对象，并将CreateEmitter对象传入到ObservableOnSubscribe中。
new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onComplete();
}
}
4）在ObservableOnSubscribe中继续调用CreateEmitter的next方法。
@Override
public void onNext(T t) {
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
if (!isDisposed()) {
observer.onNext(t);
}
}
CreateEmitter中的observer对象是ObservableSubscribeOn中的Observer对象，
5）调用ObservableSubscribeOn.SubscribeOnObserver的onNext(1)方法：
@Override
public void onNext(T t) {
actual.onNext(t);
}
ObservableSubscribeOn.SubscribeOnObserver中的actual对象又是ObservableObserveOn中的Observer对象，
6）调用ObservableObserveOn.ObserveOnObserver的next方法：
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != QueueDisposable.ASYNC) {
queue.offer(t);
}
schedule();
}
done是onSubscribe方法中赋值的，我们这里赋值是false，sourceMode也没有进行处理，所以首先保存到queue中，然后执行schedule();
void schedule() {
if (getAndIncrement() == 0) {
worker.schedule(this);
}
}
这里是限制执行一次，worker对象是subscribeActual()方法中赋值的
Scheduler.Worker w = scheduler.createWorker();
这里的scheduler是主线程的，worker对应的是ExecutorScheduler.ExecutorWorker对象，具体过程忽略。调用主线程执行worker.schedule(this);传入的this对象，该对象是Runnable对象。注意这里：由io线程切换回到了主线程中。
@Override
public void run() {
if (outputFused) {
drainFused();
} else {
drainNormal();
}
}
这里并没有设置outputFused的值，执行drainNormal();
void drainNormal() {
int missed = 1;
final SimpleQueue q = queue;
final Observer a = actual;
for (;;) {
if (checkTerminated(done, q.isEmpty(), a)) {
return;
}
for (;;) {
boolean d = done;
T v;
try {
v = q.poll();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
s.dispose();
q.clear();
a.onError(ex);
return;
}
boolean empty = v == null;
if (checkTerminated(d, empty, a)) {
return;
}
if (empty) {
break;
}
a.onNext(v);
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
如果queue中的内容是空，就执行返回，进入for无限循环中，依次poll出queue中的值，并调用 a.onNext(v);这里的a对象是最外层的Observer对象，调用最外层的Observer对象的onNext()方法。当ObservableEmitter调用onComplete()方法时，就最后会调用最外层的Observer的onComplete()方法。
到这里最简单的使用Rxjava2就完成了。