这篇对Observable常用api方法源码解读，包含just()、fromArray()、empty()、defer()、error()、cache()、timer()、fromCallable()、fromFuture()方法，最后解读一个叫Disposable的状态管理api并做总结。
1、 Observable#just(T)
@CheckReturnValue
@SchedulerSupport("none")
@NonNull
public static <T> Observable<T> just(T item) {
ObjectHelper.requireNonNull(item, "item is null");
//创建ObservableJust，订阅后下发onNext事件
return RxJavaPlugins.onAssembly(new ObservableJust(item));
}
//ObservableJust继承Observable<T>，同样由subscribe()产生订阅
@CheckReturnValue
@SchedulerSupport("none")
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {
ObjectHelper.requireNonNull(onNext, "onNext is null");
ObjectHelper.requireNonNull(onError, "onError is null");
ObjectHelper.requireNonNull(onComplete, "onComplete is null");
//创建订阅者LambdaObserver
LambdaObserver<T> ls = new LambdaObserver(onNext, onError, onComplete, Functions.emptyConsumer());
//实际调用ObservableJust#subscribeActual
this.subscribe((Observer)ls);
return ls;
}
public final class ObservableJust<T> extends Observable<T> implements ScalarSupplier<T> {
private final T value;
public ObservableJust(T value) {
this.value = value;
}
protected void subscribeActual(Observer<? super T> observer) {
//通过订阅者和下发的唯一元素创建ScalarDisposable，实现Disposable<T>, Runnable用于控制状态管理以及定义消费逻辑
ScalarDisposable<T> sd = new ScalarDisposable(observer, this.value);
//产生订阅后执行subscribe()中自定义Consumer<? super Disposable> onSubscribe逻辑
observer.onSubscribe(sd);
sd.run();
}
public T get() {
return this.value;
}
}
public void run() {
if (this.get() == 0 && this.compareAndSet(0, 2)) {
//回调订阅者observer的Consumer<T> onNext消费元素
this.observer.onNext(this.value);
if (this.get() == 2) {
this.lazySet(3);
this.observer.onComplete();
}
}
}
2、Observable#empty()
@CheckReturnValue
@SchedulerSupport("none")
public static <T> Observable<T> empty() {
//public static final Observable<Object> INSTANCE = new ObservableEmpty()创建一个ObservableEmpty对象
return RxJavaPlugins.onAssembly(ObservableEmpty.INSTANCE);
}
再来看subscribeActual()核心方法:
protected void subscribeActual(Observer<? super Object> o) {
//
EmptyDisposable.complete(o);
}
public static void complete(Observer<?> observer) {
observer.onSubscribe(INSTANCE);
//直接下发onComplete()事件，发onComplete()事件回调subscribe()中定义的消费onComplete事件逻辑
observer.onComplete();
}
3、Observable#fromArray(T... items):
@CheckReturnValue
@SchedulerSupport("none")
@NonNull
public static <T> Observable<T> fromArray(T... items) {
ObjectHelper.requireNonNull(items, "items is null");
//从T... items生产元素下发，如果元素个数为0，直接走empty逻辑，下发onComplete()事件回调订阅者订阅onComplete()事件逻辑
if (items.length == 0) {
return empty();
} else {
//如果items元素个数为1，走Observable#just(T)
//否则，创建ObservableFromArray发射元素
return items.length == 1 ? just(items[0]) : RxJavaPlugins.onAssembly(new ObservableFromArray(items));
}
}
//订阅关键逻辑
public void subscribeActual(Observer<? super T> observer) {
//ObservableFromArray：从数组发射元素的Observable
//FromArrayDisposable：实现Disposable接口，控制状态。生产者只负责生产元素，状态控制单独抽离成Disposable并让订阅者实现该接口从而具有根据状态决定是否取消订阅的能力。d代表订阅者角色。
ObservableFromArray.FromArrayDisposable<T> d = new ObservableFromArray.FromArrayDisposable(observer, this.array);
//回调observer onSubscribe()，这个可以根据需要自己实现具体逻辑(默认EmptyConsumer)
observer.onSubscribe(d);
if (!d.fusionMode) {
d.run();
}
}
//产生订阅后，执行的消费元素逻辑
void run() {
T[] a = this.array;
int n = a.length;
for(int i = 0; i < n && !this.isDisposed(); ++i) {
T value = a[i];
if (value == null) {
this.downstream.onError(new NullPointerException("The element at index " + i + " is null"));
return;
}
//遍历数组，回调LambdaObserver#onNext()消费元素
this.downstream.onNext(value);
}
if (!this.isDisposed()) {
this.downstream.onComplete();
}
}
4、Observable#defer(Supplier<? extends ObservableSource<? extends T>> supplier)
@CheckReturnValue
@SchedulerSupport("none")
@NonNull
//defer()方法接收一个Supplier<? extends ObservableSource<? extends T>> supplier，用于生产一个ObservableSource对象，但只有当执行supplier.get()，才会实际创建生产者ObservableSource
public static <T> Observable<T> defer(Supplier<? extends ObservableSource<? extends T>> supplier) {
ObjectHelper.requireNonNull(supplier, "supplier is null");
//创建ObservableDefer时，传入Supplier<? extends ObservableSource<? extends T>> supplier
return RxJavaPlugins.onAssembly(new ObservableDefer(supplier));
}
//核心方法，订阅核心逻辑
public void subscribeActual(Observer<? super T> observer) {
ObservableSource pub;
try {
//订阅产生时，才会调用supplier.get()，此时才会真正创建ObservableSource对象ObservableCreate用于发射元素
pub = (ObservableSource)ObjectHelper.requireNonNull(this.supplier.get(), "The supplier returned a null ObservableSource");
} catch (Throwable var4) {
Exceptions.throwIfFatal(var4);
EmptyDisposable.error(var4, observer);
return;
}
//调用Supplier<? extends ObservableSource<? extends T>>创建的ObservableCreate.subscribe()下发元素，之后的逻辑上篇解读过了，回调订阅者Consumer逻辑消费元素
pub.subscribe(observer);
}
可以看到defer()会延迟创建生产者发射元素，只有当订阅事件出现时才会真正创建发射器。这个api对于IO资源操作特别有用，比如数据库操作，将数据库操作定义成Lambda表达式只有当订阅真正发生时才会去交互数据库。
5、Observable#error(Supplier<? extends java.lang.Throwable>)
@CheckReturnValue
@SchedulerSupport("none")
@NonNull
public static <T> Observable<T> error(Supplier<? extends Throwable> errorSupplier) {
ObjectHelper.requireNonNull(errorSupplier, "errorSupplier is null");
//创建ObservableError用于下发error元素
return RxJavaPlugins.onAssembly(new ObservableError(errorSupplier));
}
//订阅核心逻辑
public void subscribeActual(Observer<? super T> observer) {
Throwable error;
try {
//订阅事件发生时，真正创建下发error元素的生产者，通过代码可以看到error事件的生产者就是Supplier<? extends Throwable>，下发的元素就是Throwable
error = (Throwable)ExceptionHelper.nullCheck(this.errorSupplier.get(), "Supplier returned a null Throwable.");
} catch (Throwable var4) {
Exceptions.throwIfFatal(var4);
error = var4;
}
//消费error元素逻辑
EmptyDisposable.error(error, observer);
}
//
public static void error(Throwable e, Observer<?> observer) {
observer.onSubscribe(INSTANCE);
//回调订阅者消费error事件逻辑
observer.onError(e);
}
public void onError(Throwable t) {
if (!this.isDisposed()) {
this.lazySet(DisposableHelper.DISPOSED);
try {
//消费者消费error元素逻辑，即调用在subscribe()中定义的Consumer<? super Throwable> onError
this.onError.accept(t);
} catch (Throwable var3) {
Exceptions.throwIfFatal(var3);
RxJavaPlugins.onError(new CompositeException(new Throwable[]{t, var3}));
}
} else {
RxJavaPlugins.onError(t);
}
}
6、Observable#cache()
@CheckReturnValue
@SchedulerSupport("none")
public final Observable<T> cacheWithInitialCapacity(int initialCapacity) {
ObjectHelper.verifyPositive(initialCapacity, "initialCapacity");
return RxJavaPlugins.onAssembly(new ObservableCache(this, initialCapacity));
}
abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {
//引用一个ObservableSource，之前说过ObservableSource类似于一个Consumer，定义一段生产元素的逻辑
protected final ObservableSource<T> source;
AbstractObservableWithUpstream(ObservableSource<T> source) {
this.source = source;
}
public final ObservableSource<T> source() {
return this.source;
}
}
//System#arraycopy(Object src, int srcPos,Object dest, int destPos,int length)
//这个方法JDK native方法，从注释说明它用来拷贝源数组到目标数组，给定起始索引和需要拷贝的元素个数
Copies an array from the specified source array, beginning at the specified position, to the specified position of the destination array.
* @param src the source array.
* @param srcPos starting position in the source array.
* @param dest the destination array.
* @param destPos starting position in the destination data.
* @param length the number of array elements to be copied.
@HotSpotIntrinsicCandidate
public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);
//先来看ObservableCache类：
//AbstractObservableWithUpstream extends Observable<U>
//类结构上看到，ObservableCache实现了AbstractObservableWithUpstream、Observable、Observer,说明它具有这三个角色的能力
//对于Observer而言，Observable代表一连串流动的数据，结合AbstractObservableWithUpstream，于是ObservableCache同样具备发射元素的能力，对应ObservableCache#onNext(T item)、ObservableCache#onError(Throwable t)、ObservableCache#onComplete()
//Observer代表订阅者，定义消费逻辑，订阅事件发生时消费元素，对应ObservableCache#subscribeActual(Observer<? super T> t)
public final class ObservableCache<T> extends AbstractObservableWithUpstream<T, T> implements Observer<T> {
//初始化值new AtomicBoolean()，标识首次消费
final AtomicBoolean once;
//初始化值16
final int capacityHint;
//初始化值：new ObservableCache.CacheDisposable[0]，通过AtomicReference记录了一个ObservableCache.CacheDisposable<T>[]数组的原子引用
final AtomicReference<ObservableCache.CacheDisposable<T>[]> observers;
static final ObservableCache.CacheDisposable[] EMPTY = new ObservableCache.CacheDisposable[0];
static final ObservableCache.CacheDisposable[] TERMINATED = new ObservableCache.CacheDisposable[0];
//代表上游生产者下发的元素个数
volatile long size;
//初始化值new ObservableCache.Node(capacityHint)
final ObservableCache.Node<T> head;
//初始化值new ObservableCache.Node(capacityHint)
ObservableCache.Node<T> tail;
//元素在Node存储的偏移
int tailOffset;
Throwable error;
volatile boolean done;
//初始化ObservableCache时，传入ObservableSource用于发射元素、指定Node中T[]数组容量
public ObservableCache(Observable<T> source, int capacityHint) {
super(source);
this.capacityHint = capacityHint;
this.once = new AtomicBoolean();
ObservableCache.Node<T> n = new ObservableCache.Node(capacityHint);
this.head = n;
this.tail = n;
this.observers = new AtomicReference(EMPTY);
}
//当订阅动作发生时，通过每次创建的Observer和一个全局的ObservableCache创建一个ObservableCache.CacheDisposable
protected void subscribeActual(Observer<? super T> t) {
//将产生的订阅者、ObservableCache包装成一个ObservableCache.CacheDisposable
ObservableCache.CacheDisposable<T> consumer = new ObservableCache.CacheDisposable(t, this);
//调ObservableCache#onSubscribe(Disposable d)，啥也没做
t.onSubscribe(consumer);
//存订阅者
this.add(consumer);
//这段逻辑非常重要，首先一个订阅者之前消费过的元素，不会二次消费，cache起来的元素是给后来的订阅者准备的。这个if else 表明，对于后续的订阅者，不会再去调ObservableCreate发射元素，而是直接执行replay(consumer)下发元素并回调Observer.onNext()消费。
if (!this.once.get() && this.once.compareAndSet(false, true)) {
//对于第一个订阅者，它的订阅逻辑执行这里，调用ObservableCreate发射元素委托给ObservableCache#onNext()发射元素并回调Observer消费元素，于是去看onNext()方法看它如何下发并cache元素。
this.source.subscribe(this);
} else {
//对于后来的订阅者，下发元素逻辑便执行的这里
this.replay(consumer);
}
}
boolean isConnected() {
return this.once.get();
}
boolean hasObservers() {
return ((ObservableCache.CacheDisposable[])this.observers.get()).length != 0;
}
long cachedEventCount() {
return this.size;
}
//add方法中维护了一个局部变量next用来存储每次订阅动作产生的订阅者
void add(ObservableCache.CacheDisposable<T> consumer) {
ObservableCache.CacheDisposable[] current;
ObservableCache.CacheDisposable[] next;
do {
//获取AtomicReference<ObservableCache.CacheDisposable<T>[]>引用指向的ObservableCache.CacheDisposable<T>[]
current = (ObservableCache.CacheDisposable[])this.observers.get();
if (current == TERMINATED) {
return;
}
//新new一个ObservableCache.CacheDisposable[n+1] newer，将原ObservableCache.CacheDisposable[n] older 0-n位置元素拷贝到newer的0-n位置，并让新的订阅者comsumer放到newer n+1位置上
int n = current.length;
next = new ObservableCache.CacheDisposable[n + 1];
System.arraycopy(current, 0, next, 0, n);
next[n] = consumer;
//通过AtomicReference<ObservableCache.CacheDisposable<T>[]>.compareAndSet(current, next)，将next引用指向ObservableCache.CacheDisposable<T>[]对象替换为当前引用指向对象
} while(!this.observers.compareAndSet(current, next));
}
void remove(ObservableCache.CacheDisposable<T> consumer) {
ObservableCache.CacheDisposable[] current;
ObservableCache.CacheDisposable[] next;
do {
current = (ObservableCache.CacheDisposable[])this.observers.get();
int n = current.length;
if (n == 0) {
return;
}
int j = -1;
for(int i = 0; i < n; ++i) {
if (current[i] == consumer) {
j = i;
break;
}
}
if (j < 0) {
return;
}
if (n == 1) {
next = EMPTY;
} else {
next = new ObservableCache.CacheDisposable[n - 1];
System.arraycopy(current, 0, next, 0, j);
System.arraycopy(current, j + 1, next, j, n - j - 1);
}
} while(!this.observers.compareAndSet(current, next));
}
//下发元素
void replay(ObservableCache.CacheDisposable<T> consumer) {
if (consumer.getAndIncrement() == 0) {
int missed = 1;
//
long index = consumer.index;
int offset = consumer.offset;
//ObservableCache中维护的tail引用指向的Node
ObservableCache.Node<T> node = consumer.node;
//下游消费者
Observer<? super T> downstream = consumer.downstream;
int capacity = this.capacityHint;
while(!consumer.disposed) {
boolean sourceDone = this.done;
//判断是否元素全部消费
boolean empty = this.size == index;
if (sourceDone && empty) {
consumer.node = null;
Throwable ex = this.error;
if (ex != null) {
downstream.onError(ex);
} else {
downstream.onComplete();
}
return;
}
if (!empty) {
//当前Node消费完，node偏移指向其next引用Node
if (offset == capacity) {
node = node.next;
offset = 0;
}
//实际消费元素，node为CacheDisposable中的head引用，也就是从第一个Node开始遍历元素消费
downstream.onNext(node.values[offset]);
++offset;
++index;
} else {
//下发元素全部被消费
consumer.index = index;
consumer.offset = offset;
consumer.node = node;
missed = consumer.addAndGet(-missed);
if (missed == 0) {
return;
}
}
}
consumer.node = null;
}
}
public void onSubscribe(Disposable d) {
}
//首先清楚一点，要cache元素应该在上游生产者处理，消费元素之前就先把元素缓存起来。
public void onNext(T t) {
//this.tailOffset初始值为0，当创建一个新ObservableCache.Node时并存入t时，tailOffset置为1；当直接在ObservableCache引用tail指向的ObservableCache.Node<T>节点中存入t元素于[tailOffset]索引位置时，tailOffset+1。说明tailOffset代表元素在Node节点中T[]的索引位置，值为0-initialCapacity
int tailOffset = this.tailOffset;
if (tailOffset == this.capacityHint) {
ObservableCache.Node<T> n = new ObservableCache.Node(tailOffset);
n.values[0] = t;
this.tailOffset = 1;
this.tail.next = n;
this.tail = n;
} else {
this.tail.values[tailOffset] = t;
this.tailOffset = tailOffset + 1;
}
//this.size代表上游生产下发存储了多少元素
++this.size;
//获取AtomicReference<ObservableCache.CacheDisposable<T>[]>引用指向的ObservableCache.CacheDisposable<T>[]，此时就拿到ObservableCache中维护的原子引用指向的消费者数组ObservableCache.CacheDisposable<T>[]
ObservableCache.CacheDisposable[] var7 = (ObservableCache.CacheDisposable[])this.observers.get();
int var4 = var7.length;
//遍历数组，拿到每个消费者，调用replay下发元素
for(int var5 = 0; var5 < var4; ++var5) {
ObservableCache.CacheDisposable<T> consumer = var7[var5];
this.replay(consumer);
}
}
public void onError(Throwable t) {
this.error = t;
this.done = true;
ObservableCache.CacheDisposable[] var2 = (ObservableCache.CacheDisposable[])this.observers.getAndSet(TERMINATED);
int var3 = var2.length;
for(int var4 = 0; var4 < var3; ++var4) {
ObservableCache.CacheDisposable<T> consumer = var2[var4];
this.replay(consumer);
}
}
public void onComplete() {
this.done = true;
ObservableCache.CacheDisposable[] var1 = (ObservableCache.CacheDisposable[])this.observers.getAndSet(TERMINATED);
int var2 = var1.length;
for(int var3 = 0; var3 < var2; ++var3) {
ObservableCache.CacheDisposable<T> consumer = var1[var3];
this.replay(consumer);
}
}
//Node内部维护了T[]、ObservableCache.Node<T> next
//T[]用于存储下发元素、next指针用于构建Node链表
static final class Node<T> {
final T[] values;
volatile ObservableCache.Node<T> next;
Node(int capacityHint) {
this.values = (Object[])(new Object[capacityHint]);
}
}
//局部状态管理器，和订阅者一样，每次订阅事件产生时也会创建一个订阅者对应的CacheDisposable状态管理器。
static final class CacheDisposable<T> extends AtomicInteger implements Disposable {
private static final long serialVersionUID = 6770240836423125754L;
final Observer<? super T> downstream;
final ObservableCache<T> parent;
ObservableCache.Node<T> node;
//订阅者在Node中消费到的相对位置，使用偏移量来表示
int offset;
//全局消费到的位置
long index;
volatile boolean disposed;
CacheDisposable(Observer<? super T> downstream, ObservableCache<T> parent) {
this.downstream = downstream;
this.parent = parent;
//初始化CacheDisposable状态管理器时，node 指向第一次创建的ObservableCache.Node(capacityHint)
this.node = parent.head;
}
public void dispose() {
if (!this.disposed) {
this.disposed = true;
this.parent.remove(this);
}
}
public boolean isDisposed() {
return this.disposed;
}
}
}
//AtomicReference<ObservableCache.CacheDisposable<T>[]>
小结：Observable#cache()创建一个全局的ObservableCache<T>，其内部维护一个局部消费状态管理器CacheDisposable<T>，当下游首次产生订阅时，会创建一个ObservableCache.CacheDisposable[]并将订阅者存入同时让ObservableCache维护一个指向该ObservableCache.CacheDisposable[]的引用，同时回调ObservableCache.onNext()对下发元素存入ObservableCache内部维护的Node,Node通过维护一个Object[]和next指针用于构建存储下发元素的链表，之后回调订阅者Observer.onNext()消费元素。对于后续产生的订阅，ObservableCache每次会创建一个新的ObservableCache.CacheDisposable[]，数组长度为原长度+1，并将订阅者存入，之后不会再调用ObservableCreate发射，而是直接从起始head指向的Node开始遍历元素消费，每消费完一个Node，偏移到next指向的Node继续消费数组元素。
场景：如果我们的多个订阅者，并且执行的消费逻辑比较消耗系统资源，例如数据库查询。难道每产生一个订阅都去执行数据库查询？于是可以采用cache()，首次订阅去查询数据库并将结果缓存起来，后续的订阅直接从缓存中拿到元素消费。但是cache()不同于背压设计，从源码可以看到每产生一个订阅都会new一个原订阅者数组长度+1的新数组，并且元素也会通过Node的Object[]来存储，当订阅者数量过大尤其是生产元素数量过大(比如无限流或者大数据发布流)将会导致内存溢出。-ConnectableObservable便能解决cache的缺陷，本质上去掉了存储下发元素，并在订阅时做了一个伪订阅动作用来存储消费者，在其connect()时才会真正产生订阅。
7、Observable#timer(long, java.util.concurrent.TimeUnit)
//需要传入delay、unit、Scheduler(可选，不传入时默认创建ComputationScheduler)
@CheckReturnValue
@SchedulerSupport("io.reactivex:computation")
public static Observable<Long> timer(long delay, TimeUnit unit) {
return timer(delay, unit, Schedulers.computation());
}
@CheckReturnValue
@SchedulerSupport("custom")
public static Observable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler) {
ObjectHelper.requireNonNull(unit, "unit is null");
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
//创建一个全局的ObservableTimer，传入一个ComputationScheduler
return RxJavaPlugins.onAssembly(new ObservableTimer(Math.max(delay, 0L), unit, scheduler));
}
//首先需要TimerObserver处于一个Observable角色，因此它继承了Observable
public final class ObservableTimer extends Observable<Long> {
//其次需要其有调度能力，因此采用装饰者设计模式通过维护一个Scheduler增强自身，使其具有调度能力。后面消费逻辑交给调度器Scheduler去执行即可。
final Scheduler scheduler;
final long delay;
final TimeUnit unit;
public ObservableTimer(long delay, TimeUnit unit, Scheduler scheduler) {
this.delay = delay;
this.unit = unit;
this.scheduler = scheduler;
}
public void subscribeActual(Observer<? super Long> observer) {
ObservableTimer.TimerObserver ios = new ObservableTimer.TimerObserver(observer);
observer.onSubscribe(ios);
Disposable d = this.scheduler.scheduleDirect(ios, this.delay, this.unit);
ios.setResource(d);
}
//调度器需要传入一个Runnable任务，因此继承Runnable
static final class TimerObserver extends AtomicReference<Disposable> implements Disposable, Runnable {
private static final long serialVersionUID = -2809475196591179431L;
//还需要将消费者和调度器结合起来，因此维护一个Observer用来增强调度器，使调度器能改变订阅者
final Observer<? super Long> downstream;
TimerObserver(Observer<? super Long> downstream) {
this.downstream = downstream;
}
public void dispose() {
DisposableHelper.dispose(this);
}
public boolean isDisposed() {
return this.get() == DisposableHelper.DISPOSED;
}
public void run() {
if (!this.isDisposed()) {
//消费元素
this.downstream.onNext(0L);
this.lazySet(EmptyDisposable.INSTANCE);
this.downstream.onComplete();
}
}
public void setResource(Disposable d) {
DisposableHelper.trySet(this, d);
}
}
}
接下来看订阅核心方法：
public void subscribeActual(Observer<? super Long> observer) {
//将订阅者包装为ObservableTimer.TimerObserver
ObservableTimer.TimerObserver ios = new ObservableTimer.TimerObserver(observer);
observer.onSubscribe(ios);
//通过调度器Scheduler#scheduleDirect来执行TimerObserver的run()方法
Disposable d = this.scheduler.scheduleDirect(ios, this.delay, this.unit);
ios.setResource(d);
}
//将消费逻辑包装为一个ScheduledDirectTask交给线程池ComputationScheduler.FixedSchedulerPool执行
public Disposable scheduleDirect(Runnable run, long delayTime, TimeUnit unit) {
ScheduledDirectTask task = new ScheduledDirectTask(RxJavaPlugins.onSchedule(run));
try {
Object f;
if (delayTime <= 0L) {
f = this.executor.submit(task);
} else {
f = this.executor.schedule(task, delayTime, unit);
}
task.setFuture((Future)f);
return task;
} catch (RejectedExecutionException var7) {
RxJavaPlugins.onError(var7);
return EmptyDisposable.INSTANCE;
}
}
public void run() {
if (!this.isDisposed()) {
//TimerObserver包装了下游消费者downstream，执行消费逻辑，默认消费0
this.downstream.onNext(0L);
this.lazySet(EmptyDisposable.INSTANCE);
this.downstream.onComplete();
}
}
8、Observable#fromCallable(Callable<? extends T> supplier)
Callable<? extends T>接口类似于Runnable()，但它是能接收到返回值的，不能计算到返回值时，会抛出异常。
@CheckReturnValue
@SchedulerSupport("none")
@NonNull
public static <T> Observable<T> fromCallable(Callable<? extends T> supplier) {
ObjectHelper.requireNonNull(supplier, "supplier is null");
//创建一个全局的ObservableFromCallable
return RxJavaPlugins.onAssembly(new ObservableFromCallable(supplier));
}
//生产者角色，继承Observable<T>，另外还实现了Supplier，它具有Supplier角色
public final class ObservableFromCallable<T> extends Observable<T> implements Supplier<T> {
final Callable<? extends T> callable;
public ObservableFromCallable(Callable<? extends T> callable) {
this.callable = callable;
}
//实际订阅
public void subscribeActual(Observer<? super T> observer) {
//包装订阅者
DeferredScalarDisposable<T> d = new DeferredScalarDisposable(observer);
observer.onSubscribe(d);
if (!d.isDisposed()) {
Object value;
try {
//调用callable.call()并拿到返回值
value = ExceptionHelper.nullCheck(this.callable.call(), "Callable returned a null value.");
} catch (Throwable var5) {
Exceptions.throwIfFatal(var5);
//响应式异常处理，捕捉到异常后判断如果订阅没撤销，下发一个error事件
if (!d.isDisposed()) {
observer.onError(var5);
} else {
//否则，抛出全局异常
RxJavaPlugins.onError(var5);
}
return;
}
//拿到callable结果后，调用状态管理器complete(value)
d.complete(value);
}
}
public T get() throws Throwable {
return ExceptionHelper.nullCheck(this.callable.call(), "The Callable returned a null value.");
}
}
public final void complete(T value) {
int state = this.get();
if ((state & 54) == 0) {
//获取状态管理器包装的下游消费者
Observer<? super T> a = this.downstream;
if (state == 8) {
this.value = value;
this.lazySet(16);
a.onNext((Object)null);
} else {
this.lazySet(2);
//消费元素
a.onNext(value);
}
if (this.get() != 4) {
a.onComplete();
}
}
}
9、状态管理Disposable
