Android-RxJava2线程切换原理
Android-RxJava2线程切换原理
- 源码跟进
- Observable.just(1)
- .subscribeOn(Schedulers.io())
- .observeOn(AndroidSchedulers.mainThread())
- .subscribe(new Observer() {})
- 小结
- 时序图
源码跟进
Observable.just(1)
Observable被观察者这个类里面有1万多行代码，里面基本很多方法的重载，
下面我们来看看这里面的源码。我们加上注释来看比较方便
我们跟进Observable.just(1) 这个方法进去看看里面的处理，最后返回了Observable被观察者对象出来了
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> just(T item) {
//这里在检测传入进来的泛型是否为空
ObjectHelper.requireNonNull(item, "The item is null");
//RxJavaPlugins.onAssembly这里是个钩子函数
//ObservableJust是一个被观察者
//public final class ObservableJust extends Observable implements ScalarCallable { 是我们被观察者Observable的子类
return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));
}
//我们根据RxJavaPlugins.onAssembly这个方法点进去，看看这个方法的注释hook
/**
* Calls the associated hook function.
* @param the value type
* @param source the hook's input value
* @return the value returned by the hook
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
@NonNull
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
//第一次进来的时候onObservableAssembly是个空，因为没有做赋值
Function<? super Observable, ? extends Observable> f = onObservableAssembly;
if (f != null) {
//这里等于是把传进来的被观察者对象进行了一次加工，然后返回出去。
return apply(f, source);
}
//所以第一次就直接将这个观察者return出去了
return source;
}
.subscribeOn(Schedulers.io())
指定被观察者执行线程Observable.just(1).subscribeOn(Schedulers.io())还是返回了被观察者对象
跟进源码去看看
//这个Schedulers.io()跟进来，找了下这个IO的赋值，是在Schedulers类中有个静态代码块
static {
......
//赋值IO 跟进new IOTask()源码会发现return了一个new IoScheduler()对象
IO = RxJavaPlugins.initIoScheduler(new IOTask());
......
}
@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));
}
//我们来看看ObservableSubscribeOn这个对象
ObservableSubscribeOn 继承 AbstractObservableWithUpstream
AbstractObservableWithUpstream 还是继承 Observable这个被观察者
.observeOn(AndroidSchedulers.mainThread())
下面我们来看看
.observeOn(AndroidSchedulers.mainThread())这个方法的调用，同样返回的还是个Observable
//AndroidSchedulers.mainThread()点进去
//值得一提的是package io.reactivex.android.schedulers;
//AndroidSchedulers是RxAndroid里面的类
public static Scheduler mainThread() {
//同样是个钩子函数
return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
}
//我们跟进AndroidSchedulers这个类的MAIN_THREAD去看看发现
private static final class MainHolder {
//原来里面是创建了一个HandlerScheduler对象
//并new Handler，我们在Handler机制中是不是有印象？
//Looper.getMainLooper() 主线程的Looper对象，
//这里就创建了主线程的Handler对象并保存进去了
//因为应用程序中只会有一个主线程，ActivityThread中创建了全局唯一的主线程
static final Scheduler DEFAULT = new HandlerScheduler(new Handler(Looper.getMainLooper()));
}
//这个MAIN_THREAD 最终返回的是上面这个MainHolder.DEFAULT
private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
new Callable<Scheduler>() {
@Override public Scheduler call() throws Exception {
return MainHolder.DEFAULT;
}
});
//Observable类中
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.CUSTOM)
public final Observable<T> observeOn(Scheduler scheduler) {
//调用observeOn方法 第一个参数是上一个被观察者执行的线程
//第二个参数是是否错误（onError延时调用）
//第三个参数缓冲区的大小
return observeOn(scheduler, false, bufferSize());
}
//上面调用的observeOn方法，这个方法返回Observable被观察者对象
@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));
}
.subscribe(new Observer() {})
继续往下走，订阅观察者
.subscribe(new Observer() {})订阅观察者
subscribe传入了一个观察者对象
public interface Observer<T> //这是一个接口
//下面是被观察者Observable中subscribe这个订阅方法
//传入一个观察者
@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer<? super T> observer) {
//先判空观察者
ObjectHelper.requireNonNull(observer, "observer is null");
try {
//钩子函数将我们观察者插入进去
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
//抽象方法，具体实现在子类ObservableObserveOn
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
// can't call onError because no way to know if a Disposable has been set or not
// can't call onSubscribe because the call might have set a Subscription already
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}
//ObservableObserveOn#subscribeActual(observer)
@Override
protected void subscribeActual(Observer<? super T> observer) {
if (scheduler instanceof TrampolineScheduler) {
source.subscribe(observer);
} else {
//这里的 scheduler(抽象类) 就是（子类） HandlerScheduler 对象 得到了一个工作线程对象
Scheduler.Worker w = scheduler.createWorker();
//source 就是上一级 subscribeOn 中创建的 ObservableSubscribeOn 对象
//内部创建一个 ObserveOnObserver 包装成一个Runnable对象 传入的 observer观察者 对象。
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
}
}
//子类HandlerScheduler 的实现方式
@Override
public Worker createWorker() {
return new HandlerWorker(handler);
}
//source.subscribe 最终调用到Observabl里面的subscribe方法
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete, Consumer<? super Disposable> onSubscribe) {
ObjectHelper.requireNonNull(onNext, "onNext is null");
ObjectHelper.requireNonNull(onError, "onError is null");
ObjectHelper.requireNonNull(onComplete, "onComplete is null");
ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");
//包装观察者
LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);
//传入到重载的方法中 一层一层的往上去处理
subscribe(ls);
return ls;
}
//通过调用subscribe后最终调用到了ObservableSubscribeOn 类里面的subscribeActual这个方法中
@Override
public void subscribeActual(final Observer<? super T> s) {
//将 s 作为构造传入 SubscribeOnObserver
//SubscribeOnObserver 它即是 observer 类型，也是 disposable 类型。
//这里是在包装观察者
//进行了观察者多次包装......
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
//观察者的onSubscribe方法的调用回调过去
s.onSubscribe(parent);
//设置被观察者的运行线程，运行
parent.setDisposable(scheduler.scheduleDirect(new Runnable() {
@Override
public void run() {
//被观察者中subscribe方法传入了多次包装后的观察者
source.subscribe(parent);
}
}));
}
//紧接着上面设置运行线程时scheduler.scheduleDirect方法调用
//Scheduler类中的scheduleDirect方法
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
//创建一个 worker 线程
final Worker w = createWorker();
//包装传进来的run 对象
final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
//DisposeTask 还是继承了Runnable对象
DisposeTask task = new DisposeTask(decoratedRun, w);
//由 worker 去执行这个任务
w.schedule(task, delay, unit);
return task;
}
//创建Worker工作线程
@Override
public Worker createWorker() {
//EventLoopWorker这个对象封装了一个 pool 这个的池子
return new EventLoopWorker(pool.get());
}
//DisposeTask 对象里面做的事情
static final class DisposeTask implements Runnable, Disposable {
final Runnable decoratedRun;
final Worker w;
Thread runner;
DisposeTask(Runnable decoratedRun, Worker w) {
this.decoratedRun = decoratedRun;
this.w = w;
}
@Override
public void run() {
//获取了当前线程
runner = Thread.currentThread();
try {
//真正任务 decoratedRun 是在 外层传入进来的run 方法中被执行。
decoratedRun.run();
} finally {
//任务执行完毕之后调用关闭连接器。
dispose();
runner = null;
}
}
@Override
public void dispose() {
if (runner == Thread.currentThread() && w instanceof NewThreadWorker) {
((NewThreadWorker)w).shutdown();
} else {
//这里也会通过 w.dispose() 进行关闭 worker 的执行
w.dispose();
}
}
@Override
public boolean isDisposed() {
return w.isDisposed();
}
}
//w.dispose();EventLoopWorker.dispose的方法的实现执行
@Override
public void dispose() {
if (once.compareAndSet(false, true)) {
tasks.dispose();
// releasing the pool should be the last action
//释放一个 threadWorker ，将其添加到 expiringWorkerQueue 队列中
pool.release(threadWorker);
}
}
void release(ThreadWorker threadWorker) {
// Refresh expire time before putting worker back in pool
threadWorker.setExpirationTime(now() + keepAliveTime);
//添加到 expiringWorkerQueue 队列中
expiringWorkerQueue.offer(threadWorker);
}
//开始执行w.schedule(task, delay, unit);
@Override
public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
if (tasks.isDisposed()) {
// don't schedule, we are unsubscribed
return EmptyDisposable.INSTANCE;
}
//真正去执行任务的就是 threadWorker
return threadWorker.scheduleActual(action, delayTime, unit, tasks);
}
//threadWorker.scheduleActual调用的是 NewThreadWorker类里面的这个方法
@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;
}
Observable.just(1) //被观察者
.subscribeOn(Schedulers.io()) //被观察者
.observeOn(AndroidSchedulers.mainThread()) //被观察者
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
//这里调用还没到线程切换，这里还是当前创建调用的线程
}
@Override
public void onNext(Integer integer) {
System.out.println("just----"+integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
小结
大概就是，在创建操作的时候，创建出一个Observable被观察者，指定被观察者线程的时候，返回了一个Observable观察者，指定观察者线程时返回一个Obsevable，通过一层一层的包装Obsevable，subscribe订阅观察者时，然后开始包装观察者Obseva，创建主线程时通过new Handler（主线程Loop对象）得到，被观察者线程被进行包装Runable，具体操作被观察者的时候，是一层一层往上走，最终在线程池中进行执行，最终通过handler切换主线程将任务发出。
消化起来需要时间… 各位大神勿喷，谢谢 来看看这张时序图
时序图
