测试用例:
new Thread( new Runnable() {
@Override
public void run() {
rxjavaTest();
}
},"rxjava_test").start();
@SuppressLint("CheckResult")
private void rxjavaTest() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
LOG_TAG("subscribe");
emitter.onNext("test");
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
LOG_TAG("onSubscribe");
}
@Override
public void onNext(String s) {
LOG_TAG("onNext");
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
private void LOG_TAG(String prefix){
Log.d(TAG,prefix + " ;"+Thread.currentThread().getName());
}
显示结果,3个方法在一个线程中:
2019-12-02 17:05:21.843 18402-18434/com.mi.learn.rxjava D/Rxjava-Study: onSubscribe ;rxjava_test
2019-12-02 17:05:21.843 18402-18434/com.mi.learn.rxjava D/Rxjava-Study: subscribe ;rxjava_test
2019-12-02 17:05:21.843 18402-18434/com.mi.learn.rxjava D/Rxjava-Study: onNext ;rxjava_test
分析代码:
ObservableOnSubscribe
public interface ObservableOnSubscribe<T> {
void subscribe(@NonNull ObservableEmitter<T> emitter) throws Throwable;
}
Observable#create
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
发现,经过Observable.create方法,会将ObservableOnSubscribe封装成ObservableCreate类型;
然后看Observable#subscribe方法干了啥?
public final Disposable subscribe(Consumer<? super T> onNext) {
return subscribe(onNext, Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION);
}
@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer<? super T> observer) {
...
subscribeActual(observer);
...
throw npe;
}
}
关键就是调用subscribeActual方法,此时回头看上方在执行到subscribe方法,其实就是过程是
ObservableCreate#subscribeActual的方法:
来看其源码:
@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);
}
}
其会subscribeActual(observer)的observer是subscribe(new Observer)这里面的new出来的;
CreateEmitter<T> parent = new CreateEmitter<T>(observer);会将这个new Observer封装成CreateEmitter,之后直接执行observer.onSubscribe方法;因此日志打印最开始执行的是
2019-12-02 17:05:21.843 18402-18434/com.mi.learn.rxjava D/Rxjava-Study: onSubscribe ;rxjava_test
;之后看下 source.subscribe(parent)方法;其中source是回头
Observable#create
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
这个source就是new ObservableOnSubscribe,因此source.subscribe会调用到ObservableOnSubscribe#subscribe方法,所以第二个打印的会是:
2019-12-02 17:05:21.843 18402-18434/com.mi.learn.rxjava D/Rxjava-Study: subscribe ;rxjava_test
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
LOG_TAG("subscribe");
emitter.onNext("test");
}
调用 emitter.onNext("test");时候,因为 observer.onSubscribe(parent)这里面的parent是将ObservableEmitter封装成CreateEmitter,所以在调用onNext时候会回调到CreateEmitter#onNext方法,代码如下:
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
@Override
public void onNext(T t) {
if (t == null) {
onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
return;
}
if (!isDisposed()) {
observer.onNext(t);
}
}
}
所以在打印
2019-12-02 17:05:21.843 18402-18434/com.mi.learn.rxjava D/Rxjava-Study: onNext ;rxjava_test
流程图大概如下:
graph TD
id1(ObservableOnSubscribe)
id2(ObservableCreate)
id3(Observer)
id1 --> id2
id2 --subscribe--> id3
现在添加一些事件切换过程,比如map,flatMap
@SuppressLint("CheckResult")
private void rxjavaTest() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
LOG_TAG("subscribe");
emitter.onNext("test");
}
})
.map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
LOG_TAG("test map");
return "test map";
}
})
.flatMap(new Function<String, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(String s) throws Exception {
return new ObservableSource<String>() {
@Override
public void subscribe(Observer<? super String> observer) {
LOG_TAG("test flatMap");
observer.onNext("test flatMap");
}
};
}
})
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
LOG_TAG("onSubscribe");
}
@Override
public void onNext(String s) {
LOG_TAG("onNext:"+s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
打印日志结果如下:
2019-12-02 17:31:54.740 19012-19042/com.mi.learn.rxjava D/Rxjava-Study: onSubscribe ;rxjava_test
2019-12-02 17:31:54.740 19012-19042/com.mi.learn.rxjava D/Rxjava-Study: subscribe ;rxjava_test
2019-12-02 17:31:54.740 19012-19042/com.mi.learn.rxjava D/Rxjava-Study: test map ;rxjava_test
2019-12-02 17:31:54.741 19012-19042/com.mi.learn.rxjava D/Rxjava-Study: test flatMap ;rxjava_test
2019-12-02 17:31:54.741 19012-19042/com.mi.learn.rxjava D/Rxjava-Study: onNext:test flatMap ;rxjava_test
看下Observable#map/flatMap:
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}
public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
...
return RxJavaPlugins.onAssembly(new ObservableFlatMap<T, R>(this, mapper, delayErrors, maxConcurrency, bufferSize));
}
分析源码发现,其实也就是将事件封装,从ObservableCreate封装成ObservableMap/ObservableFlatMap;
来看ObservableMap源码:
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function));
}
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
final Function<? super T, ? extends U> mapper;
MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
if (sourceMode != NONE) {
downstream.onNext(null);
return;
}
...
downstream.onNext(v);
}
}
其中当调用subscribe方法时候,会调用到ObservableCreate#subscribeActual(observer)方法,而ObservableCreate#subscribeActual中的observer是封装后的ObservableMap/ObservableFlatMap,
因此会调用到ObservableMap/ObservableFlatMap#subscribeActual,所以会显按顺序打印出来日志,流程如下;
graph TD
id1(ObservableOnSubscribe)
id2(ObservableCreate)
id3(ObservableMap)
id4(ObservableFlatMap)
id5(Observer)
id1 --> id2
id2 --> id3
id3 --> id4
id4 --subscribe--> id5
切断事件联系:Disposable
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
LOG_TAG("subscribe");
emitter.onNext("test");
emitter.onNext("test1");
emitter.onNext("test2");
emitter.onNext("test3");
}
}).subscribe(
new Observer<String>() {
private Disposable mDisposable = null;
@Override
public void onSubscribe(Disposable d) {
LOG_TAG("onSubscribe");
mDisposable = d;
}
@Override
public void onNext(String s) {
LOG_TAG("onNext:" + s);
if (s.equals("test2")){
mDisposable.dispose();
}
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
在发送事件时候,最后是调用到ObservableCreate#subscribeActual方法,执行ObservableEmitter封装的CreateEmitter方法发送onNext事件,代码如下:
CreateEmitter#onNext
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);
}
}
public boolean isDisposed() {
return DisposableHelper.isDisposed(get());
}
public static boolean isDisposed(Disposable d) {
return d == DISPOSED;
}
public static boolean dispose(AtomicReference<Disposable> field) {
Disposable current = field.get();
Disposable d = DISPOSED;
if (current != d) {
current = field.getAndSet(d);
if (current != d) {
if (current != null) {
current.dispose();
}
return true;
}
}
return false;
}
这里会判断是否isDisposed,如果是,则不在执行后续的onNext方法,事件也就被抛弃;
事件发送是串型发送,非并行
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
LOG_TAG("subscribe");
emitter.onNext("test");
emitter.onNext("test1");
emitter.onNext("test2");
emitter.onNext("test3");
}
}).subscribe(
new Observer<String>() {
private Disposable mDisposable = null;
@Override
public void onSubscribe(Disposable d) {
LOG_TAG("onSubscribe");
mDisposable = d;
}
@Override
public void onNext(String s) {
if (s.equals("test2")){
SystemClock.sleep(10000);
}
LOG_TAG("onNext:" + s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
打印结果:
2019-12-03 19:58:59.485 6200-6222/com.mi.learn.rxjava D/Rxjava-Study: onSubscribe ;rxjava_test
2019-12-03 19:58:59.485 6200-6222/com.mi.learn.rxjava D/Rxjava-Study: subscribe ;rxjava_test
2019-12-03 19:58:59.485 6200-6222/com.mi.learn.rxjava D/Rxjava-Study: onNext:test ;rxjava_test
2019-12-03 19:58:59.486 6200-6222/com.mi.learn.rxjava D/Rxjava-Study: onNext:test1 ;rxjava_test
2019-12-03 19:59:09.487 6200-6222/com.mi.learn.rxjava D/Rxjava-Study: onNext:test2 ;rxjava_test
2019-12-03 19:59:09.487 6200-6222/com.mi.learn.rxjava D/Rxjava-Study: onNext:test3 ;rxjava_test
结果显示onNext:test1和onNext:test2 事件差10S;
前面说的都没设计到线程,其实设计线程也就是多2个封装类而已,就是ObservableObserveOn/ObservableSubscribeOn
@SuppressLint("CheckResult")
private void rxjavaTest() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
LOG_TAG("subscribe");
emitter.onNext("test");
}
})
.map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
LOG_TAG("test map");
return "test map";
}
})
.flatMap(new Function<String, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(String s) throws Exception {
return new ObservableSource<String>() {
@Override
public void subscribe(Observer<? super String> observer) {
LOG_TAG("test flatMap");
observer.onNext("test flatMap");
}
};
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
LOG_TAG("onSubscribe");
}
@Override
public void onNext(String s) {
LOG_TAG("onNext:"+s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
打印日志如下:
2019-12-02 17:59:40.959 19257-19279/com.mi.learn.rxjava D/Rxjava-Study: onSubscribe ;rxjava_test
2019-12-02 17:59:40.986 19257-19284/com.mi.learn.rxjava D/Rxjava-Study: subscribe ;RxCachedThreadScheduler-1
2019-12-02 17:59:40.986 19257-19284/com.mi.learn.rxjava D/Rxjava-Study: test map ;RxCachedThreadScheduler-1
2019-12-02 17:59:40.986 19257-19284/com.mi.learn.rxjava D/Rxjava-Study: test flatMap ;RxCachedThreadScheduler-1
2019-12-02 17:59:41.060 19257-19257/com.mi.learn.rxjava D/Rxjava-Study: onNext:test flatMap ;main
来分析一波,subscribeOn/observeOn
public final Observable<T> subscribeOn(Scheduler scheduler) {
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}
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));
}
将上面返回的observable封装成ObservableSubscribeOn/ObservableObserveOn;
还是分析subscribeActual方法:
ObservableSubscribeOn#subscribeActual
@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)));
}
首先会将上面返回的ObservableFlatMap封装成SubscribeOnObserver,然后调用onSubscribe方法,注意ObservableCreate#subscribeActual方法也有observer.onSubscribe:
protected void subscribeActual(Observer<? super T> c) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
注意这里打印的onSubscribe日志是ObservableSubscribeOn#subscribeActual打印来出的,
原因是因为Override了onSubscribe方法,当ObservableCreate#subscribeActual中调用observer.onSubscribe时候,调用到SubscribeOnObserver#onSubscribe就没了;
static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {
private static final long serialVersionUID = 8094547886072529208L;
final Observer<? super T> downstream;
@Override
public void onSubscribe(Disposable d) {
DisposableHelper.setOnce(this.upstream, d);
}
}
如果有多个onSubscribe(xxx)方法,那么调用的也会是最后一次调用到ObservableSubscribeOn#subscribeActual中的observer.onSubscribe(parent);
到这里还没有出现过线程切换问题,因此onSubscribe日志打印就在当前方法执行的线程中,也会是第一个执行的方法,日志如下:
19279/com.mi.learn.rxjava D/Rxjava-Study: onSubscribe ;rxjava_test
接下来会来看subscribe是如何执行的,以及执行在哪个线程中,
onSubscribe完后
会执行parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
;
先分析下SubscribeTask源码
final class SubscribeTask implements Runnable {
private final SubscribeOnObserver<T> parent;
SubscribeTask(SubscribeOnObserver<T> parent) {
this.parent = parent;
}
@Override
public void run() {
source.subscribe(parent);
}
}
发现其是继承Runnable,Run方法中就会执行subscribe方法,其中,source就是封装传递过来的Observable,直到调用到ObservableCreate#subscribeActual执行 source.subscribe(parent);打印ObservableOnSubscribe#subscribe中回调方法日志;
因此第二个打印日志是
2019-12-02 17:59:40.986 19257-19284/com.mi.learn.rxjava D/Rxjava-Study: subscribe ;RxCachedThreadScheduler-1
接下来分析下其执行线程,
observable.subscribeOn(Schedulers.io())
@NonNull
public static Scheduler io() {
return RxJavaPlugins.onIoScheduler(IO);
}
IO = RxJavaPlugins.initIoScheduler(new IOTask());
static final class IOTask implements Callable<Scheduler> {
@Override
public Scheduler call() throws Exception {
return IoHolder.DEFAULT;
}
}
static final class IoHolder {
static final Scheduler DEFAULT = new IoScheduler();
}
public IoScheduler() {
this(WORKER_THREAD_FACTORY);
}
public IoScheduler(ThreadFactory threadFactory) {
this.threadFactory = threadFactory;
this.pool = new AtomicReference<CachedWorkerPool>(NONE);
start();
}
然后回来看线程执行:
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
scheduler是IoScheduler;
@NonNull
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;
}
接下来看Worker是如何创建的,代码如下
public Worker createWorker() {
return new EventLoopWorker(pool.get());
}
public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
if (tasks.isDisposed()) {
// don't schedule, we are unsubscribed
return EmptyDisposable.INSTANCE;
}
return threadWorker.scheduleActual(action, delayTime, unit, tasks);
}
public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
...
Future<?> f;
try {
if (delayTime <= 0) {
f = executor.submit((Callable<Object>)sr);
} else {
f = executor.schedule((Callable<Object>)sr, delayTime, unit);
}
sr.setFuture(f);
}
...
return sr;
}
来看这个executor是从哪里来的:
public Worker createWorker() {
return new EventLoopWorker(pool.get());
}
EventLoopWorker(CachedWorkerPool pool) {
this.pool = pool;
this.tasks = new CompositeDisposable();
this.threadWorker = pool.get();
}
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;
}
static final class ThreadWorker extends NewThreadWorker {
private long expirationTime;
ThreadWorker(ThreadFactory threadFactory) {
super(threadFactory);
this.expirationTime = 0L;
}
}
public NewThreadWorker(ThreadFactory threadFactory) {
executor = SchedulerPoolFactory.create(threadFactory);
}
public static ScheduledExecutorService create(ThreadFactory factory) {
final ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, factory);
tryPutIntoPool(PURGE_ENABLED, exec);
return exec;
}
到这就看出来,其实整个过程,就是往线程池中submit/schedule添加线程去执行,所以执行过程是在线程池指定线程中;如果指定多个
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
LOG_TAG("subscribe");
emitter.onNext("test");
}
}).subscribeOn(Schedulers.io())
.subscribeOn(Schedulers.single())
.subscribeOn(AndroidSchedulers.mainThread())
打印的日志subscribe也只是运行在第一次指定的线程中,因此subscribe方法调用递归往上执行,最下方subscribeOn(AndroidSchedulers.mainThread())会先执行,最后才执行subscribeOn(Schedulers.io()),因此执行到ObservableCreate#subscribeActual时候是运行在第一次执行的线程中;
解析来看observeOn过程:
先分析下AndroidSchedulers.mainThread()如何指定运行到主线程的:
public static Scheduler mainThread() {
return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
}
private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
new Callable<Scheduler>() {
@Override public Scheduler call() throws Exception {
return MainHolder.DEFAULT;
}
});
private static final class MainHolder {
static final Scheduler DEFAULT
= new HandlerScheduler(new Handler(Looper.getMainLooper()), false);
}
HandlerScheduler(Handler handler, boolean async) {
this.handler = handler;
this.async = async;
}
@Override
@SuppressLint("NewApi") // Async will only be true when the API is available to call.
public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) {
...
ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
Message message = Message.obtain(handler, scheduled);
if (async) {
message.setAsynchronous(true);
}
handler.sendMessageDelayed(message, unit.toMillis(delay));
return scheduled;
}
@Override
public Worker createWorker() {
return new HandlerWorker(handler, async);
}
到这里其实以及知道,切换主线程是根据Android的Handler+Message方法去切换的;
然后分析下observable.observeOn(AndroidSchedulers.mainThread())过程
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));
}
ObservableObserveOn继续分析其subscribeActual方法
@Override
protected void subscribeActual(Observer<? super T> observer) {
//指定当前线程,直接执行
if (scheduler instanceof TrampolineScheduler) {
source.subscribe(observer);
} else {
//创建Worker
Scheduler.Worker w = scheduler.createWorker();
//这里注意,subscribe并没有执行运行线程哦
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
}
}
我们知道大概流程是一直调用到subscribe直到ObservableCreate#subscribeActual执行ObservableOnSubscribe#subscribe方法,调用emitter#onNext过程与subscribe相反;
来看ObserveOnObserver代码:
final Observer<? super T> downstream;
final Scheduler.Worker worker;
ObserveOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) {
this.downstream = actual;
this.worker = worker;
this.delayError = delayError;
this.bufferSize = bufferSize;
}
这里创建的work传递的是HandlerScheduler#HandlerWorker,然后执行看其回调的onNext方法:
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != QueueDisposable.ASYNC) {
queue.offer(t);
}
schedule();
}
void schedule() {
if (getAndIncrement() == 0) {
worker.schedule(this);
}
}
至此,这里OnNext执行线程已经确定了;
public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
...
ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
Message message = Message.obtain(handler, scheduled);
message.obj = this;
if (async) {
message.setAsynchronous(true);
}
handler.sendMessageDelayed(message, unit.toMillis(delay));
...
return scheduled;
}
这样就完成了线程切换过程,其实纵观全局,发现ObservableSubscribeOn#subscribeActual指定的是从下往上subscribe过程运行在哪个线程,而ObservableObserveOn#subscribeActual是指定从上往下的onNext过程运行在哪个线程;
总结:
1.每执行一个过程,其实都是对Observable进行一次封装;
2.subscribe是从下往上执行,其执行最终是执行subscribeActual方法,简称上游;
3.onNext/onComplete/onError是回调过程,从上往下执行,简称下游;
4.指定上游线程使用subscribeOn(xxx),指定下游使用observeOn(xxx)
5.切断事件发送使用Disposable#dispose;
6.onNext事件是串型发送,非并行发送,前一个耗时久,后面就得等;
盗用网上一张图:
image.png
最后来一个练习:
//主线程执行:
private void rxjavaTest() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
LOG_TAG("subscribe");
emitter.onNext("test");
}
})
.subscribeOn(Schedulers.single())
.observeOn(Schedulers.io())
.map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
LOG_TAG("map1");
return "test map1";
}
})
.lift(new ObservableOperator<String, String>() {
@Override
public Observer<? super String> apply(Observer<? super String> observer) throws Exception {
LOG_TAG("lift");
return observer;
}
})
.subscribeOn(Schedulers.io())
.map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
LOG_TAG("map2");
return "test map2";
}
})
.observeOn(AndroidSchedulers.mainThread())
.map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
LOG_TAG("map3");
return "test map1";
}
})
.subscribe(
new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
LOG_TAG("onSubscribe");
}
@Override
public void onNext(String s) {
LOG_TAG("onNext:" + s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
ObservableLift#subscribeActual
public void subscribeActual(Observer<? super R> observer) {
Observer<? super T> liftedObserver;
try {
liftedObserver = ObjectHelper.requireNonNull(operator.apply(observer), "Operator " + operator + " returned a null Observer");
}
...
source.subscribe(liftedObserver);
}
lift中apply方法是在source.subscribe之前执行,因此属于上游时候执行;
ObservableMap#subscribeActual
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function));
}
MapObserver.java
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
final Function<? super T, ? extends U> mapper;
MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
...
try {
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
}
...
downstream.onNext(v);
}
可以看出map的apply方法是在downstream.onNext方法之前执行,因此属于下游方法;
打印日志:
2019-12-03 20:36:30.013 7486-7486/com.mi.learn.rxjava D/Rxjava-Study: onSubscribe ;main
2019-12-03 20:36:30.014 7486-7510/com.mi.learn.rxjava D/Rxjava-Study: lift ;RxCachedThreadScheduler-1
2019-12-03 20:36:30.016 7486-7514/com.mi.learn.rxjava D/Rxjava-Study: subscribe ;RxSingleScheduler-1
2019-12-03 20:36:30.017 7486-7515/com.mi.learn.rxjava D/Rxjava-Study: map1 ;RxCachedThreadScheduler-2
2019-12-03 20:36:30.017 7486-7515/com.mi.learn.rxjava D/Rxjava-Study: map2 ;RxCachedThreadScheduler-2
2019-12-03 20:36:30.038 7486-7486/com.mi.learn.rxjava D/Rxjava-Study: map3 ;main
2019-12-03 20:36:30.038 7486-7486/com.mi.learn.rxjava D/Rxjava-Study: onNext:test map1 ;main
网友评论