先來看一下使用demo
Observable.create(new ObservableOnSubscribe<String>() {
@Override public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("test");
}
}).flatMap(new Function<String, ObservableSource<String>>() {
@Override public ObservableSource<String> apply(String s) throws Exception {
return Observable.just(s + " by flatMap");
}
}).subscribe(new Consumer<String>() {
@Override public void accept(String s) throws Exception {
// accept "test by flatMap"
}
});
先看Observable源碼中,我們上面用的flatMap方法定義
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper) {
return flatMap(mapper, false);
}
最終是調用了
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
// 非空判斷，忽略
ObjectHelper.requireNonNull(mapper, "mapper is null");
// 這兩個都是大于0判斷，忽略
ObjectHelper.verifyPositive(maxConcurrency, "maxConcurrency");
ObjectHelper.verifyPositive(bufferSize, "bufferSize");
// 我們并未實現ScalarCallable接口，所以不會進入 if 中
if (this instanceof ScalarCallable) {
@SuppressWarnings("unchecked")
T v = ((ScalarCallable<T>)this).call();
if (v == null) {
return empty();
}
return ObservableScalarXMap.scalarXMap(v, mapper);
}
// 重點。下面具體分析
return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));
}
首先看下RxJavaPlugins.onAssembly()方法
/**
* Calls the associated hook function.
* @param <T> the value type
* @param source the hook's input value
* @return the value returned by the hook
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
@NonNull
// 根據注釋可以知道這是一個關于hook的方法
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
Function<? super Observable, ? extends Observable> f = onObservableAssembly;
// 我們使用時默認都沒有hook，所以 f 為 null，不會進入 if中
if (f != null) {
return apply(f, source);
}
// 這里直接返回了 source，即 傳遞過來的 new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize)
return source;
}
那么看下ObservableFlatMap類，先看它的subscribeActual方法，這個方法是當ObservableFlatMap被訂閱時真正調用的方法。源碼如下：
@Override
public void subscribeActual(Observer<? super U> t) {
// 不會進入，忽略
if (ObservableScalarXMap.tryScalarXMapSubscribe(source, t, mapper)) {
return;
}
// 使用MergeObserver包裝原Observer
source.subscribe(new MergeObserver<T, U>(t, mapper, delayErrors, maxConcurrency, bufferSize));
}
繼續看MergeObserver的 onNext方法
@Override
public void onNext(T t) {
// safeguard against misbehaving sources
if (done) {
return;
}
ObservableSource<? extends U> p;
try {
// mapper.apply(t) 將調用上面demo中的
// @Override public ObservableSource<String> apply(String s) throws Exception {
// return Observable.just(s + " by flatMap");
// }
// 并將 Observable.just(s + " by flatMap");的返回值賦值給 p
p = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
upstream.dispose();
onError(e);
return;
}
// maxConcurrency默認大小就是Integer.MAX_VALUE，我們沒有改變，所以不會進入 if中
if (maxConcurrency != Integer.MAX_VALUE) {
synchronized (this) {
if (wip == maxConcurrency) {
sources.offer(p);
return;
}
wip++;
}
}
// 最終會執行這里
subscribeInner(p);
}
再繼續往下看subscribeInner源碼
@SuppressWarnings("unchecked")
void subscribeInner(ObservableSource<? extends U> p) {
for (;;) {
// p 并不是Callable，所以不會進入 if
if (p instanceof Callable) {
if (tryEmitScalar(((Callable<? extends U>)p)) && maxConcurrency != Integer.MAX_VALUE) {
boolean empty = false;
synchronized (this) {
p = sources.poll();
if (p == null) {
wip--;
empty = true;
}
}
if (empty) {
drain();
break;
}
} else {
break;
}
} else {
// 又將MergeObserver包裝成 InnerObserver
InnerObserver<T, U> inner = new InnerObserver<T, U>(this, uniqueId++);
if (addInner(inner)) {
p.subscribe(inner);
}
break;
}
}
}
可以看到又將MergeObserver包裝成 InnerObserver ，直接看InnerObserver的onNext方法
@Override
public void onNext(U t) {
// funsionMode 默認是 None，進入 if，調用的是上面的 MergeObserable 的 tryEmit 方法
if (fusionMode == QueueDisposable.NONE) {
parent.tryEmit(t, this);
} else {
parent.drain();
}
}
MergeObserable 的 tryEmit 方法
void tryEmit(U value, InnerObserver<T, U> inner) {
if (get() == 0 && compareAndSet(0, 1)) {
downstream.onNext(value);
if (decrementAndGet() == 0) {
return;
}
} else {
SimpleQueue<U> q = inner.queue;
if (q == null) {
q = new SpscLinkedArrayQueue<U>(bufferSize);
inner.queue = q;
}
q.offer(value);
if (getAndIncrement() != 0) {
return;
}
}
drainLoop();
}
MergeObserver 繼承了 AtomicInteger，所以這里的tryEmit方法就利用了 AtomicInteger 的同步機制，所以同時只會有一個 value 被 actual Observer 發射，而且這里 剛好 可以解答我們上面留下的 問題，由于 AtomicInteger CAS鎖只能保證操作的原子性，并不保證鎖的獲取順序，是搶占式的，所以最終數據的發射順序并不是固定的（同一個Observable發出的數據是有序的）
如果沒有獲取到鎖，就會將要發射的數據放入 隊列中，drainLoop 方法會循環去獲取隊列中的 數據，然后發射，由于篇幅有限，更詳細的調用過程大家可以看源碼。
