说在前面，两个角色：Observable和Observer。Observable是被观察者，是事件的发起者，在Rxjava事件流里面处于上游；Observer是观察者，是事件的接收者，在Rxjava事件流里面处于下游。当然，这个上下游是相对的，从源码可以看到Rxjava的操作符大多都是继承了Observable（意味着它对于下游来说是一个被观察者）并接收上游的被观察者作为自己的成员变量；同时，其内部会定义一个观察者类，用于订阅接收的上游观察者（意味着它对于上游来说是一个观察者）。操作符起着承上启下的作用，每个操作符都装饰拓展了不同的功能，这是Rxjava最基本的理念。接下来我们看下Rxjava的线程调度。示例代码如下：
private void createObservable() {
mObservable = Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Object> emitter) {
Log.e("MainActivity", "subscribe");
emitter.onNext("123");
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribeWith(new DisposableObserver<Object>() {
@Override
public void onNext(@NonNull Object o) {
Log.e("MainActivity", "onNext");
}
@Override
public void onError(@NonNull Throwable e) {
}
@Override
public void onComplete() {
}
});
}
以上代码运行时候，第5-6行会在子线程运行，当然，是因为我们使用了Schedulers.io进行任务调度，第14行会在主线程回调，归功于AndroidSchedulers.mainThread。
任务创建
当我们通过subscribeWith与最下游的观察者关联订阅的时候，此时链路被完全打通，观察者会一级一级的往上订阅，依次调用到每个Observable的subscribe方法
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <E extends Observer<? super T>> E subscribeWith(E observer) {
subscribe(observer);
return observer;
}
@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer<? super T> observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
...
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}
protected abstract void subscribeActual(Observer<? super T> observer);
Observable里面会调用subscribeActual方法进行真正的订阅，subscribeActual为抽象方法，由子类去实现。那这里的子类是谁呢？对，就是它上游被观察者的实例，是通过observeOn(AndroidSchedulers.mainThread())创建的ObservableObserveOn实例，它里面实现的subscribeActual方法。
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.CUSTOM)
public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
ObjectHelper.verifyPositive(bufferSize, "bufferSize");
return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
}
public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler scheduler;
final boolean delayError;
final int bufferSize;
public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
super(source);
this.scheduler = scheduler;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
if (scheduler instanceof TrampolineScheduler) {
source.subscribe(observer);
} else {
Scheduler.Worker w = scheduler.createWorker();
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
}
}
...
}
可以看到在subscribeActual方法里面调用了source的subscribe方法，这里的source就是构造函数里面传递进来的上游的被观察者。通过source.subsribe，让ObserveOnObserver对象去订阅source。ObserveOnObserver就是ObservableObserveOn内部的一个观察者，它把下游通过subscribeActual传递过来的观察者包装后，交给了上游的被观察者
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>implements Observer<T>, Runnable {
...
ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
this.downstream = actual;
this.worker = worker;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
@Override
public void onSubscribe(Disposable d) {
...
downstream.onSubscribe(this);
...
}
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != QueueDisposable.ASYNC) {
queue.offer(t);
}
schedule();
}
@Override
public void onError(Throwable t) {
...
schedule();
}
@Override
public void onComplete() {
...
schedule();
}
void schedule() {
if (getAndIncrement() == 0) {
worker.schedule(this);
}
}
@Override
public void run() {
if (outputFused) {
drainFused();
} else {
drainNormal();
}
}
void drainNormal() {
final SimpleQueue<T> q = queue;
final Observer<? super T> a = downstream;
...
T v;
v = q.poll();
...
a.onNext(v);
}
}
当source调用onNext、onError、onComplete的时候，实际调用的是ObserveOnObserver对象对应的方法，通过schedule()，经过AndroidSchedulers.mainThread()调度，最终会把这个对象包装成一个message对象（看到这个类实现了Runnable了嘛），当message从messageQueue取出来交给主线程里面的handler处理的时候，run（第43行）方法就已经在主线程里面执行了。看一下drainNormal()方法里面，最终会调用downstream的onNext，别忘了，downstream是我们在subscribeActual里面传递进来的下游的观察者，是谁？想想，对，就是我们最终通过subscribeWith传进来的观察者DisposableObserver，所以，DisposableObserver里面onNext就会在主线程被回调。
.subscribeWith(new DisposableObserver<Object>() {
@Override
public void onNext(@NonNull Object o) {
Log.e("MainActivity", "onNext");
}
@Override
public void onError(@NonNull Throwable e) {
}
@Override
public void onComplete() {
}
接下来看看AndroidSchedulers.mainThread是个啥
public final class AndroidSchedulers {
private static final class MainHolder {
static final Scheduler DEFAULT
= new HandlerScheduler(new Handler(Looper.getMainLooper()), false);
}
final class HandlerScheduler extends Scheduler {
private final Handler handler;
private final boolean async;
HandlerScheduler(Handler handler, boolean async) {
this.handler = handler;
this.async = async;
}
@Override
public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) {
if (run == null) throw new NullPointerException("run == null");
if (unit == null) throw new NullPointerException("unit == null");
run = RxJavaPlugins.onSchedule(run);
ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
handler.postDelayed(scheduled, unit.toMillis(delay));
return scheduled;
}
...
}
看到Looper.getMainLooper()就已经很明白了，消息肯定是在主线程处理。核心就是这里
private static final class HandlerWorker extends Worker {
private final Handler handler;
private final boolean async;
private volatile boolean disposed;
HandlerWorker(Handler handler, boolean async) {
this.handler = handler;
this.async = async;
}
@Override
@SuppressLint("NewApi")
public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
...
ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
Message message = Message.obtain(handler, scheduled);
message.obj = this;
handler.sendMessageDelayed(message, unit.toMillis(delay));
}
调度的时候通过handler.sendMessageDelayed发送消息，哪里调度的？上游观察者调用onNext、onError…的时候。
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>implements Observer<T>, Runnable {
@Override
public void onNext(T t) {
...
schedule();
}
@Override
public void onError(Throwable t) {
...
schedule();
}
@Override
public void onComplete() {
...
schedule();
}
void schedule() {
if (getAndIncrement() == 0) {
worker.schedule(this);
}
}
}
好了，说完了AndroidSchedulers.mainThread，再接着说往上看看subscribeOn(Schedulers.io())做了啥
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.CUSTOM)
public final Observable<T> subscribeOn(Scheduler scheduler) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}
public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler scheduler;
public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
}
@Override
public void subscribeActual(final Observer<? super T> observer) {
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
observer.onSubscribe(parent);
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
...
static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
private static final long serialVersionUID = 8094547886072529208L;
final Observer<? super T> downstream;
final AtomicReference<Disposable> upstream;
SubscribeOnObserver(Observer<? super T> downstream) {
this.downstream = downstream;
this.upstream = new AtomicReference<Disposable>();
}
@Override
public void onSubscribe(Disposable d) {
DisposableHelper.setOnce(this.upstream, d);
}
@Override
public void onNext(T t) {
downstream.onNext(t);
}
@Override
public void onError(Throwable t) {
downstream.onError(t);
}
@Override
public void onComplete() {
downstream.onComplete();
}
}
...
final class SubscribeTask implements Runnable {
private final SubscribeOnObserver<T> parent;
SubscribeTask(SubscribeOnObserver<T> parent) {
this.parent = parent;
}
@Override
public void run() {
source.subscribe(parent);
}
}
}
跟之前分析一样它也是一个被观察者（AbstractObservableWithUpstream 继承自Observable），它里面有对下游观察者的包装，SubscribeOnObserver。在订阅发生的时候，SubscribeOnObserver就会被包装成一个SubscribeTask，交给Schedulers.io进行调度。SubscribeTask是一个Runnable，写过线程的我们都清楚，最终线程执行的时候，其实就是在线程里面调用Runnable的run方法执行（第60行）： source.subscribe(parent)。source不用说了，就是我们上游的观察者，parent，就是对下游观察者包装的SubscribeOnObserver实例。再往上去找我们的source，很明显，就是通过Observable.create创建的最上游被观察者ObservableCreate 对象。
Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Object> emitter) {
Log.e("MainActivity", "subscribe");
emitter.onNext("123");
}
})
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
private static final long serialVersionUID = -3434801548987643227L;
final Observer<? super T> observer;
CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void onNext(T t) {
...
observer.onNext(t);
...
}
}
...
}
看到了吗，在subscribeActual里面又调用了（第14行）source.subscribe(parent)。这里CreateEmitter又是对下游观察者的包装，当上游被观察者调用了onNext的时候，实际就会调用下游观察者的onNext，一级一级把参数传递下去。
这里的source就是我们自己new出来的ObservableOnSubscribe对象了。通过subscribe传递进来的就是下游观察者的包装对象了，当我们自己调用emitter.onNext，消息就会往下游传递。
mObservable = Observable.create(new ObservableOnSubscribe<Object>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Object> emitter) {
Log.e("MainActivity", "subscribe");
emitter.onNext("123");
}
})
再说回source.subscribe(parent)方法，前面说过，线程执行的其实是SubscribeTask对象的run方法（下面第9行），
final class SubscribeTask implements Runnable {
private final SubscribeOnObserver<T> parent;
SubscribeTask(SubscribeOnObserver<T> parent) {
this.parent = parent;
}
@Override
public void run() {
source.subscribe(parent);
}
}
}
逐级往上，我们找到了source.subscribe(parent)方法，那就意味着。当最下游的订阅发生的时候，在子线程里面最终会执行我们最初创建被观察者的subscribe方法
@Override
public void subscribe(@NonNull ObservableEmitter<Object> emitter) {
Log.e("MainActivity", "subscribe");
emitter.onNext("123");
}
so，上面第3-4行代码就在我们的子线程里面执行了。
消息处理的线程变化我们已经了解了，现在就来看看，我们的任务（SubscribeTask->run->subscribe）是怎么通过Schedulers.io进行调度的。
任务调度
前面说到，subscribe方法的执行，是在我们订阅发生的时候，看下ObservableSubscribeOn的subscribeActual方法。
public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler scheduler;
public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
}
@Override
public void subscribeActual(final Observer<? super T> observer) {
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
observer.onSubscribe(parent);
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
...
}
上面第15行会通过scheduler进行调度。Scheduler是所有调度器的基类，而Scheduler.io的实现类是IoScheduler，Scheduler里面的scheduleDirect方法如下：
@NonNull
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
final Worker w = createWorker();
final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
DisposeTask task = new DisposeTask(decoratedRun, w);
w.schedule(task, delay, unit);
return task;
}
这里使用DisposeTask再次对SubscribeTask进行了包装，后面我会详细聊到它，目前我们只需要知道它就是一个Runnable，需要丢给线程去执行的。createWorker是Scheduler里面的一个抽象方法，具体实现是在IoScheduler里面
public final class IoScheduler extends Scheduler {
@NonNull
@Override
public Worker createWorker() {
return new EventLoopWorker(pool.get());
}
}
里面创建了一个EventLoopWorker,他是IoScheduler里面的一个静态内部类， EventLoopWorker主要包含了从IoScheduler获取过来的CachedWorkerPool和一个ThreadWorker。
static final class EventLoopWorker extends Scheduler.Worker {
private final CompositeDisposable tasks;
private final CachedWorkerPool pool;
private final ThreadWorker threadWorker;
final AtomicBoolean once = new AtomicBoolean();
EventLoopWorker(CachedWorkerPool pool) {
this.pool = pool;
this.tasks = new CompositeDisposable();
this.threadWorker = pool.get();
}
@Override
public void dispose() {
if (once.compareAndSet(false, true)) {
tasks.dispose();
// releasing the pool should be the last action
pool.release(threadWorker);
}
}
@Override
public boolean isDisposed() {
return once.get();
}
@NonNull
@Override
public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
...
return threadWorker.scheduleActual(action, delayTime, unit, tasks);
}
}
可以看到，最后其实是调用了threadWorker.scheduleActual进行任务调度，需要注意，这里的threadWorker对象其实是通过CachedWorkerPool调用get方法获取的，看到cache，肯定就想到threadWorker是会被复用的，这里后面聊。ThreadWorker也是IoScheduler里面的静态内部类
static final class ThreadWorker extends NewThreadWorker {
private long expirationTime;
ThreadWorker(ThreadFactory threadFactory) {
super(threadFactory);
this.expirationTime = 0L;
}
public long getExpirationTime() {
return expirationTime;
}
public void setExpirationTime(long expirationTime) {
this.expirationTime = expirationTime;
}
}
scheduleActual方法是在其父类NewThreadWorker里面实现的。
public class NewThreadWorker extends Scheduler.Worker implements Disposable {
private final ScheduledExecutorService executor;
volatile boolean disposed;
public NewThreadWorker(ThreadFactory threadFactory) {
executor = SchedulerPoolFactory.create(threadFactory);
}
...
@NonNull
public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
if (parent != null) {
if (!parent.add(sr)) {
return sr;
}
}
Future<?> f;
try {
if (delayTime <= 0) {
f = executor.submit((Callable<Object>)sr);
} else {
f = executor.schedule((Callable<Object>)sr, delayTime, unit);
}
sr.setFuture(f);
} catch (RejectedExecutionException ex) {
if (parent != null) {
parent.remove(sr);
}
RxJavaPlugins.onError(ex);
}
return sr;
}
...
}
public static ScheduledExecutorService create(ThreadFactory factory) {
final ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, factory);
tryPutIntoPool(PURGE_ENABLED, exec);
return exec;
}
NewThreadWorker内部默认会创建一个单线程的线程池。这里就要理解一个概念，IoScheduler内不是只有一个线程池进行调度，而是有多个单线程的线程池进行调度。对于每个线程池的管理者为IoScheduler.ThreadWorker。调度发生的时候，又用ScheduledRunnable包装了我们传进来的DisposeTask对象，把任务提交到了线程池，最终通过线程池来执行我们的任务，到此，Schelduler.io如何把任务提交到子线程执行的流程我们就梳理完了。
TreadWorker复用
我们最后提交给线程池的是ScheduledRunnable对象。
public final class ScheduledRunnable extends AtomicReferenceArray<Object>implements Runnable, Callable<Object>, Disposable {
public ScheduledRunnable(Runnable actual, DisposableContainer parent) {
super(3);
this.actual = actual;
this.lazySet(0, parent);
}
@Override
public Object call() {
// Being Callable saves an allocation in ThreadPoolExecutor
run();
return null;
}
@Override
public void run() {
lazySet(THREAD_INDEX, Thread.currentThread());
try {
try {
actual.run();
} catch (Throwable e) {
// Exceptions.throwIfFatal(e); nowhere to go
RxJavaPlugins.onError(e);
}
} finally {
...
}
}
}
可以看到，run方法最终调用的是actual.run()，actual就是DisposeTask对象
static final class DisposeTask implements Disposable, Runnable, SchedulerRunnableIntrospection {
@NonNull
final Runnable decoratedRun;
@NonNull
final Worker w;
@Nullable
Thread runner;
DisposeTask(@NonNull Runnable decoratedRun, @NonNull Worker w) {
this.decoratedRun = decoratedRun;
this.w = w;
}
@Override
public void run() {
runner = Thread.currentThread();
try {
decoratedRun.run();
} finally {
dispose();
runner = null;
}
}
@Override
public void dispose() {
if (runner == Thread.currentThread() && w instanceof NewThreadWorker) {
((NewThreadWorker)w).shutdown();
} else {
w.dispose();
}
}
...
}
当run方法执行完成后，最后会调用dispose方法，如果不是当前线程，就是调用Worker的dispose方法，这里worker就是我们通过IoScheduler里面通过createWorker创建的EventLoopWorker对象
static final class EventLoopWorker extends Scheduler.Worker {
private final CompositeDisposable tasks;
private final CachedWorkerPool pool;
private final ThreadWorker threadWorker;
final AtomicBoolean once = new AtomicBoolean();
EventLoopWorker(CachedWorkerPool pool) {
this.pool = pool;
this.tasks = new CompositeDisposable();
this.threadWorker = pool.get();
}
@Override
public void dispose() {
if (once.compareAndSet(false, true)) {
tasks.dispose();
// releasing the pool should be the last action
pool.release(threadWorker);
}
}
...
}
dispose方法里面会调用tasks.dispose，注意tasks是一个CompositeDisposable，当调用dispose后会在内部遍历调用所有Disposable对象的dispose方法。还记得我们调用NewThreadWorker进行任务调度的时候，传递进去了一个DisposableContainer，就是前面的tasks，在scheduleActual方法里面会吧ScheduledRunnable 对象sr添加进去（下面17行）
public class NewThreadWorker extends Scheduler.Worker implements Disposable {
private final ScheduledExecutorService executor;
volatile boolean disposed;
public NewThreadWorker(ThreadFactory threadFactory) {
executor = SchedulerPoolFactory.create(threadFactory);
}
...
@NonNull
public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
if (parent != null) {
if (!parent.add(sr)) {
return sr;
}
}
Future<?> f;
try {
if (delayTime <= 0) {
f = executor.submit((Callable<Object>)sr);
} else {
f = executor.schedule((Callable<Object>)sr, delayTime, unit);
}
sr.setFuture(f);
} catch (RejectedExecutionException ex) {
if (parent != null) {
parent.remove(sr);
}
RxJavaPlugins.onError(ex);
}
return sr;
}
...
}
那就意味着tasks.dispose调用的时候，是会调用到ScheduledRunnable内部的dispose方法
@Override
public void dispose() {
for (;;) {
Object o = get(FUTURE_INDEX);
if (o == DONE || o == SYNC_DISPOSED || o == ASYNC_DISPOSED) {
break;
}
boolean async = get(THREAD_INDEX) != Thread.currentThread();
if (compareAndSet(FUTURE_INDEX, o, async ? ASYNC_DISPOSED : SYNC_DISPOSED)) {
if (o != null) {
((Future<?>)o).cancel(async);
}
break;
}
}
}
注意第11行调用了Future的cancel方法，具体实现是在FutureTask里面如下：
public boolean cancel(boolean mayInterruptIfRunning) {
if (!(state == NEW &&
U.compareAndSwapInt(this, STATE, NEW,
mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
return false;
try { // in case call to interrupt throws exception
if (mayInterruptIfRunning) {
try {
Thread t = runner;
if (t != null)
t.interrupt();
} finally { // final state
U.putOrderedInt(this, STATE, INTERRUPTED);
}
}
} finally {
finishCompletion();
}
return true;
}
在第11行，会对当前线程进行打断。
接着会调用CachedWorkerPool的release方法，回收ThreadWorker（第20行）
static final class EventLoopWorker extends Scheduler.Worker {
private final CompositeDisposable tasks;
private final CachedWorkerPool pool;
private final ThreadWorker threadWorker;
final AtomicBoolean once = new AtomicBoolean();
EventLoopWorker(CachedWorkerPool pool) {
this.pool = pool;
this.tasks = new CompositeDisposable();
this.threadWorker = pool.get();
}
@Override
public void dispose() {
if (once.compareAndSet(false, true)) {
tasks.dispose();
// releasing the pool should be the last action
pool.release(threadWorker);
}
}
...
}
static final class CachedWorkerPool implements Runnable {
private final long keepAliveTime;
private final ConcurrentLinkedQueue<ThreadWorker> expiringWorkerQueue;
final CompositeDisposable allWorkers;
private final ScheduledExecutorService evictorService;
private final Future<?> evictorTask;
private final ThreadFactory threadFactory;
CachedWorkerPool(long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory) {
this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0L;
this.expiringWorkerQueue = new ConcurrentLinkedQueue<ThreadWorker>();
this.allWorkers = new CompositeDisposable();
this.threadFactory = threadFactory;
ScheduledExecutorService evictor = null;
Future<?> task = null;
if (unit != null) {
evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
task = evictor.scheduleWithFixedDelay(this, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS);
}
evictorService = evictor;
evictorTask = task;
}
@Override
public void run() {
evictExpiredWorkers();
}
ThreadWorker get() {
if (allWorkers.isDisposed()) {
return SHUTDOWN_THREAD_WORKER;
}
while (!expiringWorkerQueue.isEmpty()) {
ThreadWorker threadWorker = expiringWorkerQueue.poll();
if (threadWorker != null) {
return threadWorker;
}
}
// No cached worker found, so create a new one.
ThreadWorker w = new ThreadWorker(threadFactory);
allWorkers.add(w);
return w;
}
void release(ThreadWorker threadWorker) {
// Refresh expire time before putting worker back in pool
threadWorker.setExpirationTime(now() + keepAliveTime);
expiringWorkerQueue.offer(threadWorker);
}
void evictExpiredWorkers() {
if (!expiringWorkerQueue.isEmpty()) {
long currentTimestamp = now();
for (ThreadWorker threadWorker : expiringWorkerQueue) {
if (threadWorker.getExpirationTime() <= currentTimestamp) {
if (expiringWorkerQueue.remove(threadWorker)) {
allWorkers.remove(threadWorker);
}
} else {
// Queue is ordered with the worker that will expire first in the beginning, so when we
// find a non-expired worker we can stop evicting.
break;
}
}
}
}
long now() {
return System.nanoTime();
}
void shutdown() {
allWorkers.dispose();
if (evictorTask != null) {
evictorTask.cancel(true);
}
if (evictorService != null) {
evictorService.shutdownNow();
}
}
}
在release方法里面， 会修改前面ThreadWorker的expirationTime属性，该过期时间会设置为当前时间+keepAliveTime（默认60s）。然后将threadWorker加入到expiringWorkerQueue队列中。
CachedWorkerPool其实也是一个Runnable对象，CachedWorkerPool的另一个作用是定期销毁已过期的IoScheduler.ThreadWorker对象。evictor为执行销毁的线程池，以CachedWorkerPool作为Runnable对象。（ps：这里设置每keepAliveTime时刻触发一次，即默认为60s一次触发）。
static final class CachedWorkerPool implements Runnable {
private final long keepAliveTime;
private final ConcurrentLinkedQueue<ThreadWorker> expiringWorkerQueue;
final CompositeDisposable allWorkers;
private final ScheduledExecutorService evictorService;
private final Future<?> evictorTask;
private final ThreadFactory threadFactory;
CachedWorkerPool(long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory) {
this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0L;
this.expiringWorkerQueue = new ConcurrentLinkedQueue<ThreadWorker>();
this.allWorkers = new CompositeDisposable();
this.threadFactory = threadFactory;
ScheduledExecutorService evictor = null;
Future<?> task = null;
if (unit != null) {
evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
task = evictor.scheduleWithFixedDelay(this, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS);
}
evictorService = evictor;
evictorTask = task;
}
每触发一次线程调用，就会调用一次evictExpiredWorkers()方法。通过遍历expiringWorkerQueue找到已到过期时间的ThreadWorker并将其remove。达到释放无用的ThreadWorker效果。
小结
- 数据流向是上游往下游，说白了就是上游被观察者调用自己内部保存的下游观察者的onNext、onError等。
- 订阅是从下游往上游一级级订阅，最终订阅到我们通过Observable.create创建的被观察者那里。
- 切换到子线程，就是把被观察者的source.subscribe（observer）这个方法，包装成Runnable，再提交给线程池执行。
- 消息接收在主线程，就是把下游观察者的onNext、onError等方法，包装成一个Runnable，再通过Handler将它post到主线程执行。
915
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
