当前版本 2.2.19
RxJava2 (一)订阅流程源码阅读
RxJava2 (二)取消订阅流程 dispose( ) 源码阅读
RxJava2 (三)线程切换源码阅读
RxJava2 (四)切换UI主线程源码阅读
RxJava2 (五)just操作符源码阅读
RxJava2 (六)map操作符源码阅读
代码示例
Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
System.out.println("被观察者发射数据线程: " + Thread.currentThread().getId());
emitter.onNext(100);
}
});
// 被观察者发射消息设置为io线程
Observable<Integer> observable2 = observable1.subscribeOn(Schedulers.io());
// 观察者接收消息在Schedulers.newThread()创建的新线程中处理
Observable<Integer> observable3 = observable2.observeOn(Schedulers.newThread());
// 订阅
observable3
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
System.out.println("onSubscribe");
}
@Override
public void onNext(Integer integer) {
System.out.println("onNext: " + integer);
System.out.println("观察者接收数据线程: " + Thread.currentThread().getId());
}
@Override
public void onError(Throwable e) {
System.out.println("onError");
}
@Override
public void onComplete() {
System.out.println("onComplete");
}
});
概述
observable1对象的真实类型为ObservableCreate,它持有一个ObservableOnSubscribe对象引用.observable2对象的真实类型为ObservableSubscribeOn,它持有一个ObservableCreate对象引用.observable3对象的真实类型为ObservableObserveOn,它持有一个ObservableSubscribeOn对象引用..subscribe(Observer)方法后的API调用流程,流程脉络清楚再来看线程的切换就相当的简单了.ObservableObserveOn.subscribe(Observer)⬇ObservableObserveOn.subscribeActual(Observer)⬇ObservableSubscribeOn.subscribe(ObserveOnObserver)⬇ObservableSubscribeOn.subscribeActual(ObserveOnObserver)⬇ 这里会切换被观察者发射数据的线程ObservableCreate.subscribe(SubscribeOnObserver)⬇ObservableCreate.subscribeActual(SubscribeOnObserver)⬇ObservableOnSubscribe.subscribe(ObservableEmitter)⬇ObservableEmitter.onNext(100)⬇SubscribeOnObserver.onNext(t)⬇ObserveOnObserver.onNext(t)⬇ 这里会切换观察者接收数据的线程Observer.onNext(t)⬇
Schedulers
该类是一个工厂类,可以返回五种不同的父类类型为Scheduler的单例对象,分别是SINGLE,COMPUTATION,IO,TRAMPOLINE,NEW_THREAD.
public final class Schedulers {
// 五种单例
static final Scheduler SINGLE;
static final Scheduler COMPUTATION;
static final Scheduler IO;
static final Scheduler TRAMPOLINE;
static final Scheduler NEW_THREAD;
// 静态代码块
static {
// SingleTask,ComputationTask,IOTask,NewThreadTask 都是Schedulers类中静态内部类
// RxJavaPlugins.initSingleScheduler()最终返回的是一个SingleScheduler对象,其他的XXXTask也是一样返回XXXScheduler.
SINGLE = RxJavaPlugins.initSingleScheduler(new SingleTask());
COMPUTATION = RxJavaPlugins.initComputationScheduler(new ComputationTask());
IO = RxJavaPlugins.initIoScheduler(new IOTask());
TRAMPOLINE = TrampolineScheduler.instance();
NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new NewThreadTask());
}
// SingleTask 实现了唯一的call()方法,
// ComputationTask,IOTask,NewThreadTask 也是这种套路写出来的.
static final class SingleTask implements Callable<Scheduler> {
@Override
public Scheduler call() throws Exception {
// 返回的是SingleScheduler单例对象,下面看分析
return SingleHolder.DEFAULT;
}
}
// SingleHolder也是一个静态内部类,它会持有一个SingleScheduler对象的引用.
static final class SingleHolder {
static final Scheduler DEFAULT = new SingleScheduler();
}
}
// RxJavaPlugins类
public final class RxJavaPlugins {
// 该方法在Schedulers类中的静态代码块中被调用,并最终返回的是SingleScheduler对象
@NonNull
public static Scheduler initSingleScheduler(@NonNull Callable<Scheduler> defaultScheduler) {
Function<? super Callable<Scheduler>, ? extends Scheduler> f = onInitSingleHandler;
if (f == null) {
// defaultScheduler 参数是SingleTask对象,实现了call()方法
return callRequireNonNull(defaultScheduler);
}
return applyRequireNonNull(f, defaultScheduler);
}
@NonNull
static Scheduler callRequireNonNull(@NonNull Callable<Scheduler> s) {
try {
// 最终这里调用了s.call(),返回了SingleScheduler对象.
return ObjectHelper.requireNonNull(s.call(), "Scheduler Callable result can't be null");
} catch (Throwable ex) {
throw ExceptionHelper.wrapOrThrow(ex);
}
}
}
被观察者发射数据如何切换到IO线程中?
Schedulers.io()获取IoScheduler单例对象
public final class Schedulers {
static final Scheduler IO;
public static Scheduler io() {
// 直接返回IO
return RxJavaPlugins.onIoScheduler(IO);
}
static {
// IO真实的类型为IoScheduler.
IO = RxJavaPlugins.initIoScheduler(new IOTask());
}
}
observable1.subscribeOn(Schedulers.io()),observable1对象的真实类型为ObservableCreate.subscribeOn()方法是在Observable类中实现的.
public abstract class Observable<T> implements ObservableSource<T> {
// 将ObservableCreate对象与IoScheduler对象存储在ObservableSubscribeOn对象中,并返回
public final Observable<T> subscribeOn(Scheduler scheduler) {
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}
}
- 当
observable3调用subscribe()方法,会执行到ObservableSubscribeOn.subscribeActual(ObserveOnObserver)方法.
public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
final Scheduler scheduler;// 这个就是IoScheduler对象
public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
super(source);// 这个是ObservableCreate对象
this.scheduler = scheduler;
}
@Override
public void subscribeActual(final Observer<? super T> observer) {
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
// 这里最终会调用观察者的onSubscribe()方法
observer.onSubscribe(parent);
// scheduler.scheduleDirect(new SubscribeTask(parent)):这个方法很重要,会将ObservableCreate.subscribe()放入IO线程中执行.
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
}
scheduler.scheduleDirect(new SubscribeTask(parent))将ObservableCreate.subscribe()放入IO线程中执行
首先看下new SubscribeTask(parent)
// SubscribeTask是一个Runnable对象,
final class SubscribeTask implements Runnable {
private final SubscribeOnObserver<T> parent;
SubscribeTask(SubscribeOnObserver<T> parent) {
this.parent = parent;
}
@Override
public void run() {
// source:是ObservableCreate对象
// parent:是SubscribeOnObserver对象
source.subscribe(parent);
}
}
scheduler.scheduleDirect()做了什么?
public abstract class Scheduler {
public Disposable scheduleDirect(@NonNull Runnable run) {
return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
}
// scheduler.scheduleDirect()最终调用这里.
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
// w是EventLoopWorker类型
final Worker w = createWorker();
final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
// DisposeTask也是一个实现了Runnable接口的类, 它的run()最终会执行decoratedRun.run()
DisposeTask task = new DisposeTask(decoratedRun, w);
// schedule()最终将SubscribeTask.run()方法放入线程池中执行.
w.schedule(task, delay, unit);
return task;
}
}
- 详细的看下
scheduler.scheduleDirect()方法createWorker()获取EventLoopWorker对象
public final class IoScheduler extends Scheduler { // 这个单例就是创建线程的工厂,初始化IoScheduler时候会用到它 static final RxThreadFactory WORKER_THREAD_FACTORY; // 线程池管理类 static final CachedWorkerPool NONE; final AtomicReference<CachedWorkerPool> pool; static { WORKER_THREAD_FACTORY = new RxThreadFactory(WORKER_THREAD_NAME_PREFIX, priority); NONE = new CachedWorkerPool(0, null, WORKER_THREAD_FACTORY); } public IoScheduler() { this(WORKER_THREAD_FACTORY); } public IoScheduler(ThreadFactory threadFactory) { this.threadFactory = threadFactory; // NONE线程池管理对象 this.pool = new AtomicReference<CachedWorkerPool>(NONE); start(); } public Worker createWorker() { // pool.get(): 获取NONE单例对象. return new EventLoopWorker(pool.get()); } static final class CachedWorkerPool implements Runnable { // 获取ThreadWorker对象, 该对象中持有线程池. ThreadWorker get() { ... ThreadWorker w = new ThreadWorker(threadFactory); allWorkers.add(w); return w; } } static final class EventLoopWorker extends Scheduler.Worker { EventLoopWorker(CachedWorkerPool pool) { this.pool = pool;// 线程池管理类 this.tasks = new CompositeDisposable(); this.threadWorker = pool.get();//这里就能够获取一个线程池 } } }w.schedule(task, delay, unit);
public final class IoScheduler extends Scheduler { static final CachedWorkerPool NONE; static final class EventLoopWorker extends Scheduler.Worker { // 该对象是由单例NONE中获取的 private final ThreadWorker threadWorker; public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) { ... // 下面看ThreadWorker中的scheduleActual()方法 return threadWorker.scheduleActual(action, delayTime, unit, tasks); } } }ThreadWorker.scheduleActual(),它最终调用的是NewThreadWorker.scheduleActual()
public class NewThreadWorker extends Scheduler.Worker implements Disposable { private final ScheduledExecutorService executor; public NewThreadWorker(ThreadFactory threadFactory) { // 创建一个线程池 executor = SchedulerPoolFactory.create(threadFactory); } // 最终将Runnable对象加入到这个线程池中执行. public Disposable scheduleDirect(final Runnable run, long delayTime, TimeUnit unit) { ScheduledDirectTask task = new ScheduledDirectTask(RxJavaPlugins.onSchedule(run)); ... if (delayTime <= 0L) { f = executor.submit(task); } else { f = executor.schedule(task, delayTime, unit); } ... } }- 上面各个
Runnable中的run()方法相互之间的调用流程ScheduledRunnable.run()⬇DisposeTask.run()⬇SubscribeTask.run()⬇ObservableCreate.subscribe(SubscribeOnObserver)⬇ObservableCreate.subscribeActual(SubscribeOnObserver)⬇ObservableOnSubscribe.subscribe(ObservableEmitter)⬇ObservableEmitter.onNext(100)⬇ 这里就开始在Schedulers.io()中的线程池里发射数据.
观察者接收数据是如何切换到Schedulers.newThread()创建的新线程中?
Schedulers.newThread()获取NEW_THREAD单例对象
public final class Schedulers {
static final Scheduler IO;
public static Scheduler newThread() {
// 直接返回NEW_THREAD
return RxJavaPlugins.onNewThreadScheduler(NEW_THREAD);
}
static {
// NEW_THREAD真实的类型为NewThreadScheduler
NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new NewThreadTask());
}
}
observable2.observeOn(Schedulers.newThread()),observable2对象的真实类型为ObservableSubscribeOn.subscribeOn()方法是在Observable类中实现的.
方法最终返回ObservableObserveOn对象,该对象中持有observable2与NEW_THREAD单例对象.
public abstract class Observable<T> implements ObservableSource<T> {
public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
...
return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
}
}
- 当使用
ObservableEmitter.onNext(100)发射数据时,最终会被委托给它ObserveOnObserver.onNext(t),在概述中说过.
在上面的第二步中知道ObservableObserveOn对象中持有NEW_THREAD单例对象,再看看下何时创建的ObserveOnObserver.
public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
super(source);
this.scheduler = scheduler;// NEW_THREAD单例对象为NewThreadScheduler类型.
this.delayError = delayError;
this.bufferSize = bufferSize;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
if (scheduler instanceof TrampolineScheduler) {
source.subscribe(observer);
} else {
// 返回NewThreadWorker对象
Scheduler.Worker w = scheduler.createWorker();
// 它在这里创建的ObserveOnObserver对象.
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
}
}
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;// NewThreadWorker对象
this.delayError = delayError;
this.bufferSize = bufferSize;
}
// 用`ObservableEmitter.onNext(100)`发射的数据最后会走到这里.
@Override
public void onNext(T t) {
...
schedule();
}
void schedule() {
if (getAndIncrement() == 0) {
// 看NewThreadWorker中,ObserveOnObserver是一个Runnable类型实现了run()方法
worker.schedule(this);
}
}
}
}
worker.schedule(this);观察者接收数据的线程就是在这里切换的.
public class NewThreadWorker extends Scheduler.Worker implements Disposable {
public NewThreadWorker(ThreadFactory threadFactory) {
// 获取一个线程池
executor = SchedulerPoolFactory.create(threadFactory);
}
public Disposable schedule(@NonNull final Runnable run) {
return schedule(run, 0, null);
}
public Disposable schedule(@NonNull final Runnable action, long delayTime, @NonNull TimeUnit unit) {
...
return scheduleActual(action, delayTime, unit, null);
}
// 最终将Runnable对象加入到这个线程池中执行.
public Disposable scheduleDirect(final Runnable run, long delayTime, TimeUnit unit) {
ScheduledDirectTask task = new ScheduledDirectTask(RxJavaPlugins.onSchedule(run));
...
if (delayTime <= 0L) {
// ObserveOnObserver中的run()方法将被调用,第五步分析.
f = executor.submit(task);
} else {
f = executor.schedule(task, delayTime, unit);
}
...
}
}
- 回到
ObserveOnObserver中的run()方法中.
public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T>implements Observer<T>, Runnable {
// 第四步: executor.submit(task)将会在线程池的线程中执行run()方法.
@Override
public void run() {
if (outputFused) {
drainFused();
} else {
drainNormal();
}
}
void drainNormal() {
...
// 将消息存储在队列中
final SimpleQueue<T> q = queue;
// downstream就是用户创建的观察者对象.
final Observer<? super T> a = downstream;
// 取出消息
v = q.poll();
// 调用用户创建的Observer观察者对象的onNext(v)方法将消息传出.
a.onNext(v);
..
}
void drainFused() {
...
// 观察者中的onNext()被调用.
downstream.onNext(null);
}
}
}
638
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
