没想到啊没想到,你这浓眉大眼的家伙也是一个钩子方法。所以这行代码相当于 obsever = observer。接着看,subscribeActual(observer):
protected abstract void subscribeActual(Observer<? super T> observer);
这是一个抽象方法,没啥好分析的。接下来我们要进入正题了,根据我们编写的代码,是 ObservableSubscribeOn 这个对象调用了 subscribe 方法,所以我们看看这个类的 subscribeActual 方法。
@Override
public void subscribeActual(final Observer<? super T> s) {
final SubscribeOnObserver parent = new SubscribeOnObserver(s);
s.onSubscribe(parent);
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
这里需要注意的是 s 这个参数,后面会有很多地方看到这个参数,一定要搞清楚这个参数是谁传递过来的。比如说:
A.subscribe(B)
那么,参数 s 就是 B。
在我们的代码中是 ObservableSubscribeOn.subscribe(o); 理解了这一点,我们详细分析代码里面的内容:首先创建了一个 SubscribeOnObserver (大神教你起类名系列四)。然后调用了我们创建的对象 o 的 onSubscribe 方法:
@Override
public void onSubscribe(Disposable d) {
}
我们的 onSubscribe 方法里面啥都没做。不过一般来说,你应该调用一下 onStart 方法。
接下来是调用 parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));,setDisposable 的方法不影响流程分析,这里就先跳过了,有兴趣的可以点进去看一下。然后就是 scheduler 变量,这个变量就是我们使用 subscribeOn 传递的参数:
public final Observable subscribeOn(Scheduler scheduler) {
ObjectHelper.requireNonNull(scheduler, “scheduler is null”);
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
}
public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
}
这个 scheduler 就是 Schedulers.computation()。然后调用了它的 scheduleDirect 方法:
public Disposable scheduleDirect(@NonNull Runnable run) {
return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
}
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;
}
这两个方法是父类的,Schedulers.computation() 返回的是一个 ComputationScheduler 对象,这里找具体的实现类由于调用链比较长,就不给出了,自己点着点着就能找到了。看看 ComputationScheduler 有没有复写这两个方法:
@NonNull
@Override
public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) {
PoolWorker w = pool.get().getEventLoop();
return w.scheduleDirect(run, delay, unit);
}
它覆盖了父类的第2个 scheduleDirect 方法。这里就不深入分析里面的池了。看 w.scheduleDirect(run, delay, unit);:
public Disposable scheduleDirect(final Runnable run, long delayTime, TimeUnit unit) {
ScheduledDirectTask task = new ScheduledDirectTask(RxJavaPlugins.onSchedule(run));
try {
Future<?> f;
if (delayTime <= 0L) {
f = executor.submit(task);
} else {
f = executor.schedule(task, delayTime, unit);
}
task.setFuture(f);
return task;
} catch (RejectedExecutionException ex) {
RxJavaPlugins.onError(ex);
return EmptyDisposable.INSTANCE;
}
}
熟悉的线程池使用代码。希望看到这里你还没有忘记我们要分析的是什么。简单的归纳一下,其实就是向我们创建的 scheduler 里面提交了一个 runnable。最终这个 Runnable 肯定会执行,那么看看这个 Runnable 里面有什么代码:
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
final class SubscribeTask implements Runnable {
private final SubscribeOnObserver parent;
SubscribeTask(SubscribeOnObserver parent) {
this.parent = parent;
}
@Override
public void run() {
source.subscribe(parent);
}
}
run 方法里面就只有一句代码,但是我们需要搞清楚这里的 source 和 parent 分别是哪个对象。
parent 可以直接看到是 SubscribeOnObserver 对象。
source 是使用的外部类的变量。
public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
super(source);
this.scheduler = scheduler;
}
这里调用了 super 方法,所以构造函数里传递的变量就是 source。
public final Observable subscribeOn(Scheduler scheduler) {
ObjectHelper.requireNonNull(scheduler, “scheduler is null”);
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler));
}
这里是我们之前分析过的创建 ObservableSubscribeOn 的代码,这里的 this 指的是 observeOn 创建的 ObservableObserveOn 对象。希望看到这里你没有搞晕,如果你是使用手机看的,并且看懂了,我是真的佩服。
也就是说,run 里面的代码就是调用了 ObservableObserveOn 对象的 subscribe 方法。之前我们分析过了,subscribe 方法实际上没有做什么,只是调用了 subscribeActual 方法,所以我们进入这个类内部看看:
@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(observer, w, delayError, bufferSize));
}
}
我们在 observeOn 传递的 scheduler 不是 TrampolineScheduler 类型的,所以只需要看 else 的代码。这里是先创建了一个工作线程(由于我们使用的是 AndroidScheduler,所以这里是指的主线程),然后调用了 source 的 subscribe 方法。需要注意的是这里最后创建了一个 ObserveOnObserver 对象(大神教你起类名系列五)。
先看看 createWork,在 HandlerScheduler 中:
@Override
public Worker createWorker() {
return new HandlerWorker(handler);
}
返回了一个 HandlerWorker 对象。再看 source.subscribe(),首先这里的 source 指的是 create 方法创建的 ObservableCreate 对象,调用 subscribe 传递的是 ObserveOnObserver。看看这个对象的 subscribeActual 方法:
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter parent = new CreateEmitter(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
这里的参数 observer 是 ObserveOnObserver,source 是我们代码中创建的 oos 对象。
首先创建了一个 CreateEmitter 对象。接着看 ObserveOnObserver 的 onSubscribe 方法做了啥:
@Override
public void onSubscribe(Disposable s) {
if (DisposableHelper.validate(this.s, s)) {
this.s = s;
if (s instanceof QueueDisposable) {
@SuppressWarnings(“unchecked”)
QueueDisposable qd = (QueueDisposable) s;
int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);
if (m == QueueDisposable.SYNC) {
sourceMode = m;
queue = qd;
done = true;
actual.onSubscribe(this);
schedule();
return;
}
if (m == QueueDisposable.ASYNC) {
sourceMode = m;
queue = qd;
actual.onSubscribe(this);
return;
}
}
queue = new SpscLinkedArrayQueue(bufferSize);
actual.onSubscribe(this);
}
}
这里代码比较长,只分析重要的代码,就是 actual.onSubscribe 这句。actual 是构造函数中赋值的,所以我们回到创建 ObserveOnObserver 的地方,actual 指的是 SubscribeOnObserver 对象。所以它调用了 SubscribeOnObserver 的 onSubscribe 方法。接下来分析一下它的 onSubscribe 方法做了什么,这里不看也不会影响流程。
SubscribeOnObserver(Observer<? super T> actual) {
this.actual = actual;
this.s = new AtomicReference();
}
@Override
public void onSubscribe(Disposable s) {
DisposableHelper.setOnce(this.s, s);
}
这个方法调用了 setOnce 方法:
public static boolean setOnce(AtomicReference field, Disposable d) {
ObjectHelper.requireNonNull(d, “d is null”);
if (!field.compareAndSet(null, d)) {
d.dispose();
if (field.get() != DISPOSED) {
reportDisposableSet();
}
return false;
}
return true;
}
这里涉及到了乐观锁等玩意,简单来说就是先判断 field 的值是否为空,如果为空则设置为 d,不为空则将 d dispose。然后判断 field 的值,由于 field 的值只能设定一次非 DISPOSED 值,所以如果不为 DISPOSED,说明已经被设置过了,再报出异常,如果为 DISPOSED 是可以再次设置的。按照正常的流程,这里只是将 field 的值设置为 d,然后返回true。这个方法可以先不用管。
回到主线流程上,source.subscribe(parent); 这是最重要的一句代码。source 是在构造函数赋值的,看看构造方法:
public static Observable create(ObservableOnSubscribe source) {
ObjectHelper.requireNonNull(source, “source is null”);
return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}
也就是说这里的 source 是我们代码中创建的 oos 对象。parent 是新创建的 CreateEmitter 对象。看看我们 oos 的 subscribe 方法:
@Override
public void subscribe(ObservableEmitter e) throws Exception {
Log.e(“aprz”, Thread.currentThread().getName());
final int max = 100;
for (int i = 1; i <= max; i++) {
e.onNext(i);
}
e.onComplete();
}
这里就是事件开始的起点。所有的事件都由 ObservableEmitter 开始发送,看看它的代码,它是一个接口,在我们的例子中,它的实现类是 CreateEmitter,所有我们分析这个类的 onNext 方法:
@Override
public void onNext(T t) {
if (t == null) {
onError(new NullPointerException(“onNext called with null. Null values are generally not allowed in 2.x operators and sources.”));
return;
}
if (!isDisposed()) {
observer.onNext(t);
}
}
isDisposed 方法返回 false 才会去调用 observer 的 onNext 方法,这个 observer 是谁呢? 看到这里我们就要从后往前推一遍之前的代码了,不管你绝不绝望,反正我是很绝望。这的 observer 是 ObserveOnObserver 对象。
接下来我们就进入 ObserveOnObserver 里面,看看它接受事件之后做了什么,上面的参数 e 就是:
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != QueueDisposable.ASYNC) {
queue.offer(t);
}
schedule();
}
调用了 schedule 方法:
void schedule() {
if (getAndIncrement() == 0) {
worker.schedule(this);
}
}
向 work 中提交了一个 Runnable,这里传递的是 this。说明它自己肯定实现了这个接口,我们看看它的 run 方法做了啥:
@Override
public void run() {
if (outputFused) {
drainFused();
} else {
drainNormal();
}
}
这里一般是走 drainNormal 吧,我猜的,我们分析这个方法吧。
void drainNormal() {
int missed = 1;
final SimpleQueue q = queue;
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新
如果你觉得这些内容对你有帮助,可以添加V获取:vip204888 (备注Android)
学习福利
【Android 详细知识点思维脑图(技能树)】
其实Android开发的知识点就那么多,面试问来问去还是那么点东西。所以面试没有其他的诀窍,只看你对这些知识点准备的充分程度。so,出去面试时先看看自己复习到了哪个阶段就好。
虽然 Android 没有前几年火热了,已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了,现在高级工程师还是比较缺少的,很多高级职位给的薪资真的特别高(钱多也不一定能找到合适的),所以努力让自己成为高级工程师才是最重要的。
这里附上上述的面试题相关的几十套字节跳动,京东,小米,腾讯、头条、阿里、美团等公司19年的面试题。把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节。
由于篇幅有限,这里以图片的形式给大家展示一小部分。
网上学习 Android的资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。
一个人可以走的很快,但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎扫码加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
347347)]
学习福利
【Android 详细知识点思维脑图(技能树)】
[外链图片转存中…(img-VnFysfoQ-1712665347348)]
其实Android开发的知识点就那么多,面试问来问去还是那么点东西。所以面试没有其他的诀窍,只看你对这些知识点准备的充分程度。so,出去面试时先看看自己复习到了哪个阶段就好。
虽然 Android 没有前几年火热了,已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了,现在高级工程师还是比较缺少的,很多高级职位给的薪资真的特别高(钱多也不一定能找到合适的),所以努力让自己成为高级工程师才是最重要的。
这里附上上述的面试题相关的几十套字节跳动,京东,小米,腾讯、头条、阿里、美团等公司19年的面试题。把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节。
由于篇幅有限,这里以图片的形式给大家展示一小部分。
[外链图片转存中…(img-YPhZYk0D-1712665347348)]
网上学习 Android的资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。
一个人可以走的很快,但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎扫码加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
[外链图片转存中…(img-h5K7oH8A-1712665347349)]