这篇文章是对RxJava的流程代码分析，基于扔物线 这篇文章 给 Android 开发者的 RxJava 详解 和文章对应的RxJava库版本代码 做的解析笔记，方便理解。有不正欢迎评论指出
订阅流程：观察者模式
map 操作符
- map 操作符的整个链式调用过程对应下面这张图
- 两次map则是两次lift()转换：
- 以下面这个例子来讲：
Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
subscriber.onNext(1);
}
}).map(new Func1<Integer, String>() {
@Override
public String call(Integer integer) {
return String.valueOf(integer);
}
}).map(new Func1<String, Long>() {
@Override
public Long call(String s) {
return Long.parseLong(s);
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber<Long>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Long aLong) {
}
});
- 假设是经过以上两次map转换，则subscriber经过两次转换：
observable.lift(new Observable.Operator<Long, String>() {
@Override
public Subscriber<? super String> call(final Subscriber<? super Long> subscriber) {
// 将事件序列中的 String 对象转换为 Long 对象
return new Subscriber<String>() {
@Override
public void onNext(String s) {
subscriber.onNext(Long.parseLong(s));
}
@Override
public void onCompleted() {
subscriber.onCompleted();
}
@Override
public void onError(Throwable e) {
subscriber.onError(e);
}
};
}
});
}
observable.lift(new Observable.Operator<String, Integer>() {
@Override
//这里的subscriber1 是上面变换过后的subscriber传进来的
public Subscriber<? super Integer> call(final Subscriber<? super String> subscriber1) {
// 将事件序列中的 Integer 对象转换为 String 对象
return new Subscriber<Integer>() {
@Override
public void onNext(Integer integer) {
subscriber1.onNext(String.valueOf(integer));
}
@Override
public void onCompleted() {
subscriber1.onCompleted();
}
@Override
public void onError(Throwable e) {
subscriber1.onError(e);
}
};
}
});
- 其实最后的onNext()方法就是这样的嵌套：
onNext(Long.parese(String.valueOf(integer)))
flatMap 操作符
- 从代码看，flatMap 也是经过两次lift变换，以下面这个为例：
Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
subscriber.onNext(1);
}
}).flatMap(new Func1<Integer, Observable<String>>() {
@Override
public Observable<String> call(Integer integer) {
return Observable.just(String.valueOf(integer));
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
}
});
- subscriber 变换如下：
observable.lift(new Observable.Operator<String, Observable<String>>() {
@Override
public Subscriber<? super Observable<String>> call(final Subscriber<? super String> subscriber) {
return new Subscriber<Observable<String>>() {
@Override
public void onNext(Observable<String> observable) {
observable.subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
subscriber.onNext(s);
}
});
}
@Override
public void onCompleted() {
subscriber.onCompleted();
}
@Override
public void onError(Throwable e) {
subscriber.onError(e);
}
};
}
});
observable.lift(new Observable.Operator<Observable<String>, Integer>() {
@Override
//这里的subscriber1 是上面变换过后的subscriber传进来的
public Subscriber<? super Integer> call(final Subscriber<? super Observable<String>> subscriber1) {
// 将事件序列中的 Integer 对象转换为 Observable<String> 对象
return new Subscriber<Integer>() {
@Override
public void onNext(Integer integer) {
subscriber1.onNext(Observable.just(String.valueOf(integer)));
}
@Override
public void onCompleted() {
subscriber1.onCompleted();
}
@Override
public void onError(Throwable e) {
subscriber1.onError(e);
}
};
}
});
线程控制
public final Observable<T> subscribeOn(Scheduler scheduler) {
if (this instanceof ScalarSynchronousObservable) {
return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
}
return nest().lift(new OperatorSubscribeOn<T>(scheduler));
}
Observable类:
public final Observable<Observable<T>> nest() {
return just(this);
/**
just(this)等价如下：
Observable observable = Observable.create(new Observable.OnSubscribe<Observable<T>>() {
@Override
public void call(Subscriber<? super Observable<T>> subscriber) {
subscriber.onNext(this);-this指传递下来的Observable<T>本身
subscriber.onCompleted();
}
});
**/
}
public class OperatorSubscribeOn<T> implements Operator<T, Observable<T>> {
private final Scheduler scheduler;
public OperatorSubscribeOn(Scheduler scheduler) {
this.scheduler = scheduler;
}
@Override
public Subscriber<? super Observable<T>> call(final Subscriber<? super T> subscriber) {
final Worker inner = scheduler.createWorker();
subscriber.add(inner);
return new Subscriber<Observable<T>>(subscriber) {
@Override
public void onCompleted() {
// ignore because this is a nested Observable and we expect only 1 Observable<T> emitted to onNext
}
@Override
public void onError(Throwable e) {
subscriber.onError(e);
}
@Override
public void onNext(final Observable<T> o) {
//这里将observable.subscirbe(subscriber)整个订阅过程放到指定线程去执行
inner.schedule(new Action0() {
@Override
public void call() {
final Thread t = Thread.currentThread();
o.unsafeSubscribe(new Subscriber<T>(subscriber) {
@Override
public void onCompleted() {
subscriber.onCompleted();
}
@Override
public void onError(Throwable e) {
subscriber.onError(e);
}
@Override
public void onNext(T t) {
subscriber.onNext(t);
}
@Override
public void setProducer(final Producer producer) {
subscriber.setProducer(new Producer() {
@Override
public void request(final long n) {
if (Thread.currentThread() == t) {
// don't schedule if we're already on the thread (primarily for first setProducer call)
// see unit test 'testSetProducerSynchronousRequest' for more context on this
producer.request(n);
} else {
inner.schedule(new Action0() {
@Override
public void call() {
producer.request(n);
}
});
}
}
});
}
});
}
});
}
};
}
}
- 这里是对
Observable< Observable<T> >进行 lift() 变换操作 - 所以subscirbeOn()是对Observable.subscribe(subscriber)整个流程生效
public final Observable<T> observeOn(Scheduler scheduler) {
if (this instanceof ScalarSynchronousObservable) {
return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
}
return lift(new OperatorObserveOn<T>(scheduler));
}
- observeOn() 是直接对
Observable<T>进行lift()变换操作，指定的线程生效是在Subscriber中，具体代码可以看看OperatorObserveOn类
public final class OperatorObserveOn<T> implements Operator<T, T> {
private final Scheduler scheduler;
/**
* @param scheduler
*/
public OperatorObserveOn(Scheduler scheduler) {
this.scheduler = scheduler;
}
@Override
public Subscriber<? super T> call(Subscriber<? super T> child) {
if (scheduler instanceof ImmediateScheduler) {
// avoid overhead, execute directly
return child;
} else if (scheduler instanceof TrampolineScheduler) {
// avoid overhead, execute directly
return child;
} else {
// 生成此新Subscriber
ObserveOnSubscriber<T> parent = new ObserveOnSubscriber<T>(scheduler, child);
parent.init();
return parent;
}
}
/** Observe through individual queue per observer. */
private static final class ObserveOnSubscriber<T> extends Subscriber<T> {
final Subscriber<? super T> child;
final Scheduler.Worker recursiveScheduler;
final ScheduledUnsubscribe scheduledUnsubscribe;
final NotificationLite<T> on = NotificationLite.instance();
final Queue<Object> queue;
// the status of the current stream
volatile boolean finished = false;
@SuppressWarnings("unused")
volatile long requested = 0;
@SuppressWarnings("rawtypes")
static final AtomicLongFieldUpdater<ObserveOnSubscriber> REQUESTED = AtomicLongFieldUpdater.newUpdater(ObserveOnSubscriber.class, "requested");
@SuppressWarnings("unused")
volatile long counter;
@SuppressWarnings("rawtypes")
static final AtomicLongFieldUpdater<ObserveOnSubscriber> COUNTER_UPDATER = AtomicLongFieldUpdater.newUpdater(ObserveOnSubscriber.class, "counter");
volatile Throwable error;
// do NOT pass the Subscriber through to couple the subscription chain ... unsubscribing on the parent should
// not prevent anything downstream from consuming, which will happen if the Subscription is chained
public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> child) {
this.child = child;
this.recursiveScheduler = scheduler.createWorker();
if (UnsafeAccess.isUnsafeAvailable()) {
queue = new SpscArrayQueue<Object>(RxRingBuffer.SIZE);
} else {
queue = new SynchronizedQueue<Object>(RxRingBuffer.SIZE);
}
this.scheduledUnsubscribe = new ScheduledUnsubscribe(recursiveScheduler);
}
void init() {
child.add(scheduledUnsubscribe);
child.setProducer(new Producer() {
@Override
public void request(long n) {
BackpressureUtils.getAndAddRequest(REQUESTED, ObserveOnSubscriber.this, n);
schedule();
}
});
child.add(recursiveScheduler);
child.add(this);
}
@Override
public void onStart() {
// signal that this is an async operator capable of receiving this many
request(RxRingBuffer.SIZE);
}
@Override
public void onNext(final T t) {
if (isUnsubscribed()) {
return;
}
if (!queue.offer(on.next(t))) {
onError(new MissingBackpressureException());
return;
}
schedule();
}
@Override
public void onCompleted() {
if (isUnsubscribed() || finished) {
return;
}
finished = true;
schedule();
}
@Override
public void onError(final Throwable e) {
if (isUnsubscribed() || finished) {
return;
}
error = e;
// unsubscribe eagerly since time will pass before the scheduled onError results in an unsubscribe event
unsubscribe();
finished = true;
// polling thread should skip any onNext still in the queue
schedule();
}
final Action0 action = new Action0() {
@Override
public void call() {
pollQueue();
}
};
// 在recursiveScheduler指定的线程中执行action，action会执行 pollQueue(),所以onNxet()最终在pollQueue()中执行。
protected void schedule() {
if (COUNTER_UPDATER.getAndIncrement(this) == 0) {
recursiveScheduler.schedule(action);
}
}
// only execute this from schedule()
void pollQueue() {
int emitted = 0;
do {
counter = 1;
long produced = 0;
long r = requested;
for (;;) {
if (child.isUnsubscribed())
return;
Throwable error;
if (finished) {
if ((error = this.error) != null) {
// errors shortcut the queue so
// release the elements in the queue for gc
queue.clear();
child.onError(error);
return;
} else
if (queue.isEmpty()) {
child.onCompleted();
return;
}
}
if (r > 0) {
Object o = queue.poll();
if (o != null) {
//重点***这里就是真正的执行地方
child.onNext(on.getValue(o));
r--;
emitted++;
produced++;
} else {
break;
}
} else {
break;
}
}
if (produced > 0 && requested != Long.MAX_VALUE) {
REQUESTED.addAndGet(this, -produced);
}
} while (COUNTER_UPDATER.decrementAndGet(this) > 0);
if (emitted > 0) {
request(emitted);
}
}
}
}
}
引用扔物线里的解释： subscribeOn() 和 observeOn() 都做了线程切换的工作（图中的 "schedule..." 部位）。不同的是， subscribeOn() 的线程切换发生在 OnSubscribe 中，即在它通知上一级 OnSubscribe 时，这时事件还没有开始发送，因此 subscribeOn() 的线程控制可以从事件发出的开端就造成影响；而 observeOn() 的线程切换则发生在它内建的 Subscriber 中，即发生在它即将给下一级 Subscriber 发送事件时，因此 observeOn() 控制的是它后面的线程。
