1、filter()
源码相比后面的中间操作符api相对简单，就不贴逐句代码解读了..
源码流程解读：
①定义下发元素过程ObservableSource，返回一个Observable
②定义中间操作符filter()，传入Predicate，增强Observable并返回增强后的Observable生产者(这里是ObservableFilter)
③产生订阅,通过传入onNext()、onComplete()、onError()创建订阅者，通过包装onNext()、onComplete()、onError()为一个LambdaObserver
④通过ObservableFilter.subscribe(LambdaObserver)建立发布订阅过程，建立生产者消费者关系
⑤通过subscribeActual真正产生订阅，将LambdaObserver进行包装(装饰者设计模式，通过ObservableFilter获取到Predicate对Observer进行增强为一个FilterObserver)，然后通过执行ObservableFilter.subscribe(FilterObserver)真正产生订阅。
⑥如果有多个filter，第一个FilterObserver的上游便是Observable,下游便是第二个包装第二个Predicate而成的FilterObserver消费者，最后一个FilterObserver的下游便是消费者LambdaObserver。
⑦在ObservableFilter.subscribe(FilterObserver)中，会调用源生产者Observable.subscribeActual()遍历生产数据，进而调用下游FilterObserver消费者消费元素，如果有多个FilterObserver，会迭代全部FilterObserver，每个FilterObserver会过滤符合当前Predicate的元素并调用其下游FilterObserver消费元素，最终判断全部FilterObserver的Predicate并调用LambdaServer消费元素。
通过上面源码流程解读，可以看到，中间操作filter()是定义在消费者即FilterObserver身上。
2、Observable#map()
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}
对于map()操作符，会返回一个全新的Observable，即ObservableMap。接下来看ObservableMap源码：
//继承了AbstractObservableWithUpstream，并将上一个Observable作为参数传递进来。而继承AbstractObservableWithUpstream它便可以获取上一个Observable，这里便是Source，它指向比如ObservableFromArray，如果有多个map()，它也可能指向上一个source比如ObservableMap
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends U> function;
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
super(source);
this.function = function;
}
//实际订阅，连接生产者消费者，也就是连接source和ObservableMap类下定义的Observer，也就是将消费者传入上游源生产者来消费元素，现在跳到下面去看源生产者如ObservableFromArray下发元素源码
@Override
public void subscribeActual(Observer<? super U> t) {
//传入下游消费者，如果只有一个消费者链上只有一个MapObserver，那么它的下游消费者便是LambdaObserver，如果有多个MapObserver，它的下游消费者可能是MapObserver
source.subscribe(new MapObserver<T, U>(t, function));
}
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
final Function<? super T, ? extends U> mapper;
MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
super(actual);
this.mapper = mapper;
}
//消费者MapObserver通过onNext()来消费元素
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != NONE) {
downstream.onNext(null);
return;
}
U v;
//首先执行mapper.apply执行map()中定义的Function<? super T, ? extends R> mapper进行元素的转换
try {
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
//继续调用下游消费者消费，最终通过递归将消费者链上的MapObserver#onNext全部执行，也就是所有map(Function<? super T, ? extends R> mapper)的Function<? super T, ? extends R> mapper都会执行对下发元素进行转换，最后调用LambdaObserver#subscribe(Consumer onNext)进行消费
downstream.onNext(v);
}
@Override
public int requestFusion(int mode) {
return transitiveBoundaryFusion(mode);
}
@Nullable
@Override
public U poll() throws Throwable {
T t = qd.poll();
return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
}
}
}
再看源Observable，如ObservableFromArray.FromArrayDisposable#run():
void run() {
T[] a = array;
int n = a.length;
for (int i = 0; i < n && !isDisposed(); i++) {
T value = a[i];
if (value == null) {
downstream.onError(new NullPointerException("The element at index " + i + " is null"));
return;
}
//调用下游Observer消费元素，此时便调用下游MapObserver消费元素，继续回到MapObserver来看它消费元素源码onNext()
downstream.onNext(value);
}
if (!isDisposed()) {
downstream.onComplete();
}
}
小结：Observable#map()是一个中间操作符，每次中间操作map()都返回一个新的Observable即ObservableMap，并将上游Observable传入(第一次map()将源生产者比如ObservableFromArray传入，后续map()则将其上游的ObservableMap传入，通过extends AbstractObservableWithUpstream<T, U>并传入source)以此形成一个Observable链。当调用Observable链尾的subscribe()时，创建一个LambdaObserver，接着调用subscribeActual()真正产生订阅并传入LambdaObserver创建一个LambdaObserver的上游消费者MapObserver(通过extends BasicFuseableObserver接收一个下游消费者引用形成一个Observer链表)。ObservableMap内部维护一个MapObserver接收下游Observer和当前ObservableMap中的转换逻辑Function<? super T, ? extends U> function，当通过MapObserver#onNext()消费元素时，它先对下发元素执行function.apply(item)转换元素，然后调用其下游MapObserver#onNext()以此完成消费者链表上的全部Observer#onNext()执行消费元素。在真正产生订阅方法subscribeActual()中，下游Observable通过向上遍历Observable链表，每次创建一个MapObserver放入消费者链头节点并将该Observer节点和遍历得到的上游Observable节点建立操作关系，遍历完成时得到源生产者和消费者链表头节点Observer，并将二者绑在一起建立发布订阅过程，之后源生产者发射元素并调用消费者链头节点Observer#onNext()，一直迭代其下游消费者onNext，这样全部的消费者onNext得到执行，对元素进行function.apply(item)转换并最终由LambdaObserver#onNext消费。
3、Observable#flatMap(Function<? super T,? extendsObservableSource<? extends R>>)
@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");
ObjectHelper.verifyPositive(maxConcurrency, "maxConcurrency");
ObjectHelper.verifyPositive(bufferSize, "bufferSize");
//单值源，如ObservableJust、ObservableEmpty
if (this instanceof ScalarSupplier) {
@SuppressWarnings("unchecked")
T v = ((ScalarSupplier<T>)this).get();
if (v == null) {
return empty();
}
//源生产者为单值源时，返回一个新的Observable：ScalarXMapObservable
return ObservableScalarXMap.scalarXMap(v, mapper);
}
//非单值源，返回一个全新对象ObservableFlatMap
return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));
}
//通过ObservableScalarXMap#scalarXMap(T item,T value,
Function<? super T, ? extends ObservableSource<? extends U>> mapper)看到，当源生产者为单值源时，中间操作flatMap()返回一个叫ScalarXMapObservable的Observable，之后调用ScalarXMapObservable.subscribe()，创建LambdaObserver
public static <T, U> Observable<U> scalarXMap(T value,
Function<? super T, ? extends ObservableSource<? extends U>> mapper) {
return RxJavaPlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper));
}
接下来看ScalarXMapObservable类源码：
public final class ObservableScalarXMap {
/** Utility class. */
private ObservableScalarXMap() {
throw new IllegalStateException("No instances!");
}
/**
* Tries to subscribe to a possibly Supplier source's mapped ObservableSource.
* @param <T> the input value type
* @param <R> the output value type
* @param source the source ObservableSource
* @param observer the subscriber
* @param mapper the function mapping a scalar value into an ObservableSource
* @return true if successful, false if the caller should continue with the regular path.
*/
@SuppressWarnings("unchecked")
public static <T, R> boolean tryScalarXMapSubscribe(ObservableSource<T> source,
Observer<? super R> observer,
Function<? super T, ? extends ObservableSource<? extends R>> mapper) {
if (source instanceof Supplier) {
T t;
try {
t = ((Supplier<T>)source).get();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
EmptyDisposable.error(ex, observer);
return true;
}
if (t == null) {
EmptyDisposable.complete(observer);
return true;
}
ObservableSource<? extends R> r;
try {
r = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
EmptyDisposable.error(ex, observer);
return true;
}
if (r instanceof Supplier) {
R u;
try {
u = ((Supplier<R>)r).get();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
EmptyDisposable.error(ex, observer);
return true;
}
if (u == null) {
EmptyDisposable.complete(observer);
return true;
}
//包装一个Disposable,调用订阅者onSubscribe(Disposable)
ScalarDisposable<R> sd = new ScalarDisposable<R>(observer, u);
observer.onSubscribe(sd);
sd.run();
} else {
r.subscribe(observer);
}
return true;
}
return false;
}
/**
* Maps a scalar value into an Observable and emits its values.
*
* @param <T> the scalar value type
* @param <U> the output value type
* @param value the scalar value to map
* @param mapper the function that gets the scalar value and should return
* an ObservableSource that gets streamed
* @return the new Observable instance
*/
public static <T, U> Observable<U> scalarXMap(T value,
Function<? super T, ? extends ObservableSource<? extends U>> mapper) {
return RxJavaPlugins.onAssembly(new ScalarXMapObservable<T, U>(value, mapper));
}
/**
* Maps a scalar value to an ObservableSource and subscribes to it.
*
* @param <T> the scalar value type
* @param <R> the mapped ObservableSource's element type.
*/
//
static final class ScalarXMapObservable<T, R> extends Observable<R> {
final T value;
final Function<? super T, ? extends ObservableSource<? extends R>> mapper;
ScalarXMapObservable(T value,
Function<? super T, ? extends ObservableSource<? extends R>> mapper) {
this.value = value;
this.mapper = mapper;
}
@SuppressWarnings("unchecked")
@Override
//真正产生订阅，传入下游消费者，首次中间操作flatMap()时，下游消费者便是LambdaObserver
public void subscribeActual(Observer<? super R> observer) {
//经过mapper.apply(value)后得到的是一个ObservableSource，在其被订阅后下发元素供订阅者消费
ObservableSource<? extends R> other;
try {
other = ObjectHelper.requireNonNull(mapper.apply(value), "The mapper returned a null ObservableSource");
} catch (Throwable e) {
EmptyDisposable.error(e, observer);
return;
}
//如果经过转换后，产生的仍然是一个单值源生产者，直接拿到单值源发射元素
if (other instanceof Supplier) {
R u;
try {
//生产元素
u = ((Supplier<R>)other).get();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
EmptyDisposable.error(ex, observer);
return;
}
if (u == null) {
EmptyDisposable.complete(observer);
return;
}
ScalarDisposable<R> sd = new ScalarDisposable<R>(observer, u);
observer.onSubscribe(sd);
sd.run();
//如果不是单值源比如ObservableFromArray，调用新产生的Observable.subscribe()，并传入下游消费者。进而新产生的Observable#onNext下发元素并迭代调用消费者链，全部mapper.apply(item)得到执行，并最终由LambdaObserver来消费元素。
} else {
other.subscribe(observer);
}
}
}
/**
* Represents a Disposable that signals one onNext followed by an onComplete.
*
* @param <T> the value type
*/
public static final class ScalarDisposable<T>
extends AtomicInteger
implements QueueDisposable<T>, Runnable {
private static final long serialVersionUID = 3880992722410194083L;
final Observer<? super T> observer;
final T value;
static final int START = 0;
static final int FUSED = 1;
static final int ON_NEXT = 2;
static final int ON_COMPLETE = 3;
public ScalarDisposable(Observer<? super T> observer, T value) {
this.observer = observer;
this.value = value;
}
@Override
public boolean offer(T value) {
throw new UnsupportedOperationException("Should not be called!");
}
@Override
public boolean offer(T v1, T v2) {
throw new UnsupportedOperationException("Should not be called!");
}
@Nullable
@Override
public T poll() throws Exception {
if (get() == FUSED) {
lazySet(ON_COMPLETE);
return value;
}
return null;
}
@Override
public boolean isEmpty() {
return get() != FUSED;
}
@Override
public void clear() {
lazySet(ON_COMPLETE);
}
@Override
public void dispose() {
set(ON_COMPLETE);
}
@Override
public boolean isDisposed() {
return get() == ON_COMPLETE;
}
@Override
public int requestFusion(int mode) {
if ((mode & SYNC) != 0) {
lazySet(FUSED);
return SYNC;
}
return NONE;
}
//消费单值源生产元素，实现Runnable定义一段消费逻辑，消费单值元素就行无需返回值
@Override
public void run() {
//上游生产者下发的数据，同一个消费者只能一次消费。通过继承AtomicInteger确保多线程并发下同一个消费者消费次数的原子性
if (get() == START && compareAndSet(START, ON_NEXT)) {
//消费元素
observer.onNext(value);
if (get() == ON_NEXT) {
lazySet(ON_COMPLETE);
observer.onComplete();
}
}
}
}
}
上面说完了源生产者为单值时源码流程，再来看源生产者非单值创建一个新的ObservableFlatMap的源码:
//继承AbstractObservableWithUpstream<T, U>，构成Observable链，新建ObservableFlatMap时传入上游Observable，直接去看真正产生订阅建立过程的subscribeActual()
public final class ObservableFlatMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
final boolean delayErrors;
final int maxConcurrency;
final int bufferSize;
public ObservableFlatMap(ObservableSource<T> source,
Function<? super T, ? extends ObservableSource<? extends U>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
super(source);
this.mapper = mapper;
this.delayErrors = delayErrors;
this.maxConcurrency = maxConcurrency;
this.bufferSize = bufferSize;
}
@Override
public void subscribeActual(Observer<? super U> t) {
if (ObservableScalarXMap.tryScalarXMapSubscribe(source, t, mapper)) {
return;
}
//增强下游消费者，新建一个MergeObserver，那直接去看MergeObserver如何调用onNext()消费元素
//上游生产者迭代到源生产者发射元素，下发给消费者链上消费者通过onNext()消费元素
source.subscribe(new MergeObserver<T, U>(t, mapper, delayErrors, maxConcurrency, bufferSize));
}
static final class MergeObserver<T, U> extends AtomicInteger implements Disposable, Observer<T> {
private static final long serialVersionUID = -2117620485640801370L;
final Observer<? super U> downstream;
final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
final boolean delayErrors;
final int maxConcurrency;
final int bufferSize;
volatile SimplePlainQueue<U> queue;
volatile boolean done;
final AtomicThrowable errors = new AtomicThrowable();
volatile boolean cancelled;
final AtomicReference<InnerObserver<?, ?>[]> observers;
static final InnerObserver<?, ?>[] EMPTY = new InnerObserver<?, ?>[0];
static final InnerObserver<?, ?>[] CANCELLED = new InnerObserver<?, ?>[0];
Disposable upstream;
long uniqueId;
long lastId;
int lastIndex;
Queue<ObservableSource<? extends U>> sources;
int wip;
MergeObserver(Observer<? super U> actual, Function<? super T, ? extends ObservableSource<? extends U>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
this.downstream = actual;
this.mapper = mapper;
this.delayErrors = delayErrors;
this.maxConcurrency = maxConcurrency;
this.bufferSize = bufferSize;
if (maxConcurrency != Integer.MAX_VALUE) {
sources = new ArrayDeque<ObservableSource<? extends U>>(maxConcurrency);
}
this.observers = new AtomicReference<InnerObserver<?, ?>[]>(EMPTY);
}
@Override
public void onSubscribe(Disposable d) {
if (DisposableHelper.validate(this.upstream, d)) {
this.upstream = d;
downstream.onSubscribe(this);
}
}
//消费者消费元素
@Override
public void onNext(T t) {
// safeguard against misbehaving sources
if (done) {
return;
}
//消费下发元素时同样是新创建一个ObservableSource源，定义一段发射元素过程，在其被订阅之后发射元素供订阅者消费
ObservableSource<? extends U> p;
try {
//对下发元素经过mapper.apply(t)转换后，得到ObservableSource
p = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
upstream.dispose();
onError(e);
return;
}
//如果是多线程并发处理，将源存入队列
if (maxConcurrency != Integer.MAX_VALUE) {
synchronized (this) {
if (wip == maxConcurrency) {
//将ObservableSource存入队列
sources.offer(p);
return;
}
wip++;
}
}
//这个里面必然是每个新产生的ObservableSource被订阅时发射元素供下游订阅者消费
subscribeInner(p);
}
//方法名见名知义，订阅flatMap()内部产生的ObservableSource
@SuppressWarnings("unchecked")
void subscribeInner(ObservableSource<? extends U> p) {
for (;;) {
//如果ObservableSource是单值源
if (p instanceof Supplier) {
//直接拿到ObservableSource生产的单值元素，并调用下游消费者消费，当然了也是迭代下游消费者链执行。
if (tryEmitScalar(((Supplier<? 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 {
//如果ObservableSource是非单值源，将MergeObserver包装为一个内部的消费者InnerObserver
InnerObserver<T, U> inner = new InnerObserver<T, U>(this, uniqueId++);
//将InnerObserver保存到MergeObserver引用指向的数组InnerObserver<?, ?>[]中
if (addInner(inner)) {
//ObservableSource被订阅，接下来发射元素并被下游订阅者消费，InnerObserver#onSubscribe()得到执行
p.subscribe(inner);
}
break;
}
}
}
//将InnerObserver保存到MergeObserver引用指向的数组InnerObserver<?, ?>[]中
boolean addInner(InnerObserver<T, U> inner) {
for (;;) {
InnerObserver<?, ?>[] a = observers.get();
if (a == CANCELLED) {
inner.dispose();
return false;
}
int n = a.length;
InnerObserver<?, ?>[] b = new InnerObserver[n + 1];
System.arraycopy(a, 0, b, 0, n);
b[n] = inner;
if (observers.compareAndSet(a, b)) {
return true;
}
}
}
void removeInner(InnerObserver<T, U> inner) {
for (;;) {
InnerObserver<?, ?>[] a = observers.get();
int n = a.length;
if (n == 0) {
return;
}
int j = -1;
for (int i = 0; i < n; i++) {
if (a[i] == inner) {
j = i;
break;
}
}
if (j < 0) {
return;
}
InnerObserver<?, ?>[] b;
if (n == 1) {
b = EMPTY;
} else {
b = new InnerObserver<?, ?>[n - 1];
System.arraycopy(a, 0, b, 0, j);
System.arraycopy(a, j + 1, b, j, n - j - 1);
}
if (observers.compareAndSet(a, b)) {
return;
}
}
}
//单值源发射元素并被消费者链迭代消费
boolean tryEmitScalar(Supplier<? extends U> value) {
U u;
try {
u = value.get();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
errors.tryAddThrowableOrReport(ex);
drain();
return true;
}
if (u == null) {
return true;
}
if (get() == 0 && compareAndSet(0, 1)) {
downstream.onNext(u);
if (decrementAndGet() == 0) {
return true;
}
} else {
SimplePlainQueue<U> q = queue;
if (q == null) {
if (maxConcurrency == Integer.MAX_VALUE) {
q = new SpscLinkedArrayQueue<U>(bufferSize);
} else {
q = new SpscArrayQueue<U>(maxConcurrency);
}
queue = q;
}
if (!q.offer(u)) {
onError(new IllegalStateException("Scalar queue full?!"));
return true;
}
if (getAndIncrement() != 0) {
return false;
}
}
//下游消费者MergeObserver内部
drainLoop();
return true;
}
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();
}
@Override
public void onError(Throwable t) {
if (done) {
RxJavaPlugins.onError(t);
return;
}
if (errors.tryAddThrowableOrReport(t)) {
done = true;
drain();
}
}
@Override
public void onComplete() {
if (done) {
return;
}
done = true;
drain();
}
@Override
public void dispose() {
if (!cancelled) {
cancelled = true;
if (disposeAll()) {
errors.tryTerminateAndReport();
}
}
}
@Override
public boolean isDisposed() {
return cancelled;
}
void drain() {
//上游生产者下发的数据，同一个消费者只能一次消费，不会重复消费
if (getAndIncrement() == 0) {
drainLoop();
}
}
//这里便是消费元素核心方法
void drainLoop() {
final Observer<? super U> child = this.downstream;
int missed = 1;
for (;;) {
if (checkTerminate()) {
return;
}
SimplePlainQueue<U> svq = queue;
if (svq != null) {
for (;;) {
if (checkTerminate()) {
return;
}
U o = svq.poll();
if (o == null) {
break;
}
//下游消费者消费元素，child即为下游消费者。
child.onNext(o);
}
}
boolean d = done;
svq = queue;
InnerObserver<?, ?>[] inner = observers.get();
int n = inner.length;
int nSources = 0;
if (maxConcurrency != Integer.MAX_VALUE) {
synchronized (this) {
nSources = sources.size();
}
}
if (d && (svq == null || svq.isEmpty()) && n == 0 && nSources == 0) {
errors.tryTerminateConsumer(downstream);
return;
}
int innerCompleted = 0;
if (n != 0) {
long startId = lastId;
int index = lastIndex;
if (n <= index || inner[index].id != startId) {
if (n <= index) {
index = 0;
}
int j = index;
for (int i = 0; i < n; i++) {
if (inner[j].id == startId) {
break;
}
j++;
if (j == n) {
j = 0;
}
}
index = j;
lastIndex = j;
lastId = inner[j].id;
}
int j = index;
sourceLoop:
for (int i = 0; i < n; i++) {
if (checkTerminate()) {
return;
}
@SuppressWarnings("unchecked")
InnerObserver<T, U> is = (InnerObserver<T, U>)inner[j];
SimpleQueue<U> q = is.queue;
if (q != null) {
for (;;) {
U o;
try {
o = q.poll();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
is.dispose();
errors.tryAddThrowableOrReport(ex);
if (checkTerminate()) {
return;
}
removeInner(is);
innerCompleted++;
j++;
if (j == n) {
j = 0;
}
continue sourceLoop;
}
if (o == null) {
break;
}
child.onNext(o);
if (checkTerminate()) {
return;
}
}
}
boolean innerDone = is.done;
SimpleQueue<U> innerQueue = is.queue;
if (innerDone && (innerQueue == null || innerQueue.isEmpty())) {
removeInner(is);
if (checkTerminate()) {
return;
}
innerCompleted++;
}
j++;
if (j == n) {
j = 0;
}
}
lastIndex = j;
lastId = inner[j].id;
}
if (innerCompleted != 0) {
if (maxConcurrency != Integer.MAX_VALUE) {
while (innerCompleted-- != 0) {
ObservableSource<? extends U> p;
synchronized (this) {
p = sources.poll();
if (p == null) {
wip--;
continue;
}
}
subscribeInner(p);
}
}
continue;
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
boolean checkTerminate() {
if (cancelled) {
return true;
}
Throwable e = errors.get();
if (!delayErrors && (e != null)) {
disposeAll();
errors.tryTerminateConsumer(downstream);
return true;
}
return false;
}
boolean disposeAll() {
upstream.dispose();
InnerObserver<?, ?>[] a = observers.get();
if (a != CANCELLED) {
a = observers.getAndSet(CANCELLED);
if (a != CANCELLED) {
for (InnerObserver<?, ?> inner : a) {
inner.dispose();
}
return true;
}
}
return false;
}
}
static final class InnerObserver<T, U> extends AtomicReference<Disposable>
implements Observer<U> {
private static final long serialVersionUID = -4606175640614850599L;
final long id;
final MergeObserver<T, U> parent;
volatile boolean done;
volatile SimpleQueue<U> queue;
int fusionMode;
InnerObserver(MergeObserver<T, U> parent, long id) {
this.id = id;
this.parent = parent;
}
@Override
public void onSubscribe(Disposable d) {
if (DisposableHelper.setOnce(this, d)) {
if (d instanceof QueueDisposable) {
@SuppressWarnings("unchecked")
QueueDisposable<U> qd = (QueueDisposable<U>) d;
int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);
if (m == QueueDisposable.SYNC) {
fusionMode = m;
queue = qd;
done = true;
//调用MergeObserver，它里面维护了一个InnerObserver[]消费者数组，我们是不是需要遍历数组，让每个消费者来消费元素？
parent.drain();
return;
}
if (m == QueueDisposable.ASYNC) {
fusionMode = m;
queue = qd;
}
}
}
}
@Override
public void onNext(U t) {
if (fusionMode == QueueDisposable.NONE) {
parent.tryEmit(t, this);
} else {
parent.drain();
}
}
@Override
public void onError(Throwable t) {
if (parent.errors.tryAddThrowableOrReport(t)) {
if (!parent.delayErrors) {
parent.disposeAll();
}
done = true;
parent.drain();
}
}
@Override
public void onComplete() {
done = true;
parent.drain();
}
public void dispose() {
DisposableHelper.dispose(this);
}
}
}
小结：//////Observable.flatMap()中间操作符返回一个全新的，如果上游生产者是一个单值源时会创建一个叫ScalarXMapObservable的Observable ////源码难度太大，回头总结。
4、Observable#scan(BiFunction<T,T,T>)
中间操作符scan代表累加器，产生一个新的源ObservableScan
//传入上游源生产者，切入BiFunction<T, T, T> accumulator
public final class ObservableScan<T> extends AbstractObservableWithUpstream<T, T> {
final BiFunction<T, T, T> accumulator;
public ObservableScan(ObservableSource<T> source, BiFunction<T, T, T> accumulator) {
super(source);
this.accumulator = accumulator;
}
@Override
public void subscribeActual(Observer<? super T> t) {
//创建Observer,建立发布订阅过程
source.subscribe(new ScanObserver<T>(t, accumulator));
}
static final class ScanObserver<T> implements Observer<T>, Disposable {
final Observer<? super T> downstream;
final BiFunction<T, T, T> accumulator;
Disposable upstream;
T value;
boolean done;
ScanObserver(Observer<? super T> actual, BiFunction<T, T, T> accumulator) {
this.downstream = actual;
this.accumulator = accumulator;
}
@Override
public void onSubscribe(Disposable d) {
if (DisposableHelper.validate(this.upstream, d)) {
this.upstream = d;
downstream.onSubscribe(this);
}
}
@Override
public void dispose() {
upstream.dispose();
}
@Override
public boolean isDisposed() {
return upstream.isDisposed();
}
//下发元素回调ScanObserver#onNext()进行消费
@Override
public void onNext(T t) {
if (done) {
return;
}
final Observer<? super T> a = downstream;
T v = value;
//第一次订阅，直接消费下发元素，并将value指向第一个元素值
if (v == null) {
value = t;
a.onNext(t);
} else {
T u;
try {
//切入BiFunction<T, T, T> accumulator进行累加，后面每次下发元素和v计算和
u = ObjectHelper.requireNonNull(accumulator.apply(v, t), "The value returned by the accumulator is null");
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
upstream.dispose();
onError(e);
return;
}
//上一步计算到的和值赋给value
value = u;
//下发(accumulator.apply(v, t)计算得到的值
a.onNext(u);
}
}
@Override
public void onError(Throwable t) {
if (done) {
RxJavaPlugins.onError(t);
return;
}
done = true;
downstream.onError(t);
}
@Override
public void onComplete() {
if (done) {
return;
}
done = true;
downstream.onComplete();
}
}
}
小结：scan()操作符产生全新的Observable：ObservableScan，当订阅产生时，创建一个其内部维护的Observer：ScanObserver。消费元素时，对于第一次下发元素直接消费，并记录类变量value，后面每次下发和之前元素计算和并将和赋值给value，之后消费计算到的和数据。
