当前位置: 代码迷 >> 综合 >> Android多线程之RxJava2.0原理完全解析
  详细解决方案

Android多线程之RxJava2.0原理完全解析

热度:71   发布时间:2024-01-18 04:48:26.0

1 RxJava的基本用法

最简单的RxJava用法如下,上游可以是一个Single,也可以是一个Observal,最下游是SingleObserver,也可以是Observer。链的中间是各个节点,它们是下游的上游,也是上游的下游。它们可以实现各种功能,包括线程切换,数据转换等。

Single.just("123").subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new SingleObserver<String>() {@Overridepublic void onSubscribe(Disposable d) {}@Overridepublic void onSuccess(String value) {}@Overridepublic void onError(Throwable e) {}});

2 RxJava的源码结构分析

这里用Single作为上游,因为它的代码逻辑是最简单的。首先,看一下它的subscribe()方法。源码如下。

public final void subscribe(SingleObserver<? super T> subscriber) {ObjectHelper.requireNonNull(subscriber, "subscriber is null");subscriber = RxJavaPlugins.onSubscribe(this, subscriber);ObjectHelper.requireNonNull(subscriber, "subscriber returned by the RxJavaPlugins hook is null");try {subscribeActual(subscriber);} catch (NullPointerException ex) {throw ex;} catch (Throwable ex) {Exceptions.throwIfFatal(ex);NullPointerException npe = new NullPointerException("subscribeActual failed");npe.initCause(ex);throw npe;}
}

前面三行都是做一些判断,不会影响主要的逻辑,最重要的是 subscribeActual(subscriber)这个方法,我们看一下里面的实现,发现是个抽象方法,记住这里有个叫subscribeActual()的抽象方法,它应该会不用的类重写,实现不同的逻辑。

protected abstract void subscribeActual(SingleObserver<? super T> observer);

再看一下just()的源码,其中RxJavaPlugins.onAssembly()也是个钩子函数,所以我们只需要看new SingleJust<T>(item)里面的逻辑,发现里面只有一个方法,就是上面提到的subscribeActual()。看一下具体的逻辑,它是调用了下游的onSubscribe()和onSuccess()。什么意思呢,就是你上游用just发射了"123",下游就会依次调用onSubscribe()和onSuccess(),并且把你just传入的参数直接传入到下游中。

@Override
protected void subscribeActual(SingleObserver<? super T> s) {s.onSubscribe(Disposables.disposed());s.onSuccess(value);
}
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Single<T> just(final T item) {ObjectHelper.requireNonNull(item, "value is null");return RxJavaPlugins.onAssembly(new SingleJust<T>(item));
}

看到这里,很多人都有疑惑,逻辑这么简单吗,订阅一下,然后就调用下游的onSubscribe()和onSuccess()。那为什么看别人写的那么复杂。而且,还能实现切成切换什么的。没错,RxJava是很复杂,也有很多的操作符,能实现很多的功能,但是RxJava是很复杂,但是Single的订阅定法就是这么简单。当然,你要是调用它其它的方法,肯定还会给你做很多其它处理的。并且,在上述的代码中不可能失败的,所以不会调用它的onError(Throwable e)方法。

3 操作符map()源码分析

下面看一下一个稍微复杂的例子,使用RxJava的操作符map()对数据进行转换。

Single.just(123).map(new Function<Integer, String>() {@Overridepublic String apply(Integer integer) throws Exception {return integer + "";}}).subscribe(new SingleObserver<String>() {@Overridepublic void onSubscribe(Disposable d) {}@Overridepublic void onSuccess(String value) {}@Overridepublic void onError(Throwable e) {}});

看一下map()里面源码,最终会跳到SingleMap里面的subscribeActual()方法。

@Override
protected void subscribeActual(final SingleObserver<? super R> t) {source.subscribe(new SingleObserver<T>() {@Overridepublic void onSubscribe(Disposable d) {t.onSubscribe(d);}@Overridepublic void onSuccess(T value) {R v;try {v = mapper.apply(value);} catch (Throwable e) {Exceptions.throwIfFatal(e);onError(e);return;}t.onSuccess(v);}@Overridepublic void onError(Throwable e) {t.onError(e);}});
}

我们仔细看一下这段代码,它是调用source的subscribe()方法。先看一下,source是什么。source是在构造方法中传入的,也就是上游,意思是调用上游的subscribe()方法,参数中一个新的SingleObserver。然后在这个新的SingleObserver回调相关的逻辑。在onSubscribe()中调用t的onSubscribe()方法,那么t是什么呢,t就是对用的下游。也就是生成一个中间的对象,然后这个中间对象把对应的结果传给下游,当然,会做一些相应的处理,比如在onSuccess()会调用apply()方法,而这个apply()是接口中的方法,需要我们自己实现,在上述的例子中,已经自己实现了相应的逻辑,把Integer对象转化为String对象。

至此,我们对RxJava的框架有个更详细的了解,最关键的就是subscribeActual()这个方法,里面的逻辑就是每个相关的实现类最重要的。

4 RxJava 的线程切换详解

我们做网络请求时,经常需要切换线程,把网络请求放在后台线程中,然后把请求结果放到主线中,因为可能需要对界面做操作。这时候,我们经常需要加入如下代码。

...
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())

先看一下subscribeOn()这个方法的源码。

@SchedulerSupport(SchedulerSupport.CUSTOM)
public final Single<T> subscribeOn(final Scheduler scheduler) {ObjectHelper.requireNonNull(scheduler, "scheduler is null");return RxJavaPlugins.onAssembly(new SingleSubscribeOn<T>(this, scheduler));
}

点击SingleSubscribeOn<T>(),我们会看到如下方法

@Override
protected void subscribeActual(final SingleObserver<? super T> s) {final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s, source);s.onSubscribe(parent);Disposable f = scheduler.scheduleDirect(parent);parent.task.replace(f);}

最关键的是scheduler.scheduleDirect(parent)这个方法,

public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) {final Worker w = createWorker();final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);w.schedule(new Runnable() {@Overridepublic void run() {try {decoratedRun.run();} finally {w.dispose();}}}, delay, unit);return w;
}

我们看到,里面进行了线程的切换,最终是调用传进来的Runnable的run()方法。前面的逻辑可以看到,它是切换上游的线程。那么,想象一下,如果同时调用两次subscribeOn(),会发生什么事呢。第二次调用的,会让第一次调用的切换线程,第一次调用的,会让源Observal起作用。而这个subscribeOn()本来就是指定开始运行在哪个线程。所以,第二次调用subscribeOn()不会起作用。

同理,我们可以得出结论,subscribeOn()只在第一次调用时有用,后面都不会起作用。

下面,我们再看一下observeOn()的源码,我们可以看到它的subscribeActual()方法如下。

@Override
protected void subscribeActual(final SingleObserver<? super T> s) {source.subscribe(new ObserveOnSingleObserver<T>(s, scheduler));
}

再看一下ObserveOnSingleObserver的一些关键方法。

@Override
public void onSubscribe(Disposable d) {if (DisposableHelper.setOnce(this, d)) {actual.onSubscribe(this);}
}@Override
public void onSuccess(T value) {this.value = value;Disposable d = scheduler.scheduleDirect(this);DisposableHelper.replace(this, d);
}@Override
public void onError(Throwable e) {this.error = e;Disposable d = scheduler.scheduleDirect(this);DisposableHelper.replace(this, d);
}@Override
public void run() {Throwable ex = error;if (ex != null) {actual.onError(ex);} else {actual.onSuccess(value);}
}

在onSuccess()中,我们看到,它调用了scheduler的scheduleDirect()方法。这个方法是用来调度线程的,需要传入一个Runnable对象,这里传入了this,证明它本身实现run()接口。看一下run()接口中的代码。如果error为空,就调用actual的onSuccess()方法。再来看一下这个actual是什么,没错,他就是下游。

看到这里就很清楚了,observeOn()就是改变下游的线程。当调用多个observeOn()时,它们都会起作用。第一个observeOn()改变的是它下游的线程,在这可以做相关的操作,随后调用第二个observeOn(),它会改变它下游的线程,但不会影响它上游的线程。

5 Scheduler的原理解析

我们切换到子线程时,经常会用到Schedulers.newThread()和Schedulers.io()这两个方法,切换到主线程时,经常会用到AndroidSchedulers.mainThread()这个方法,那么,它们是怎么实现的呢,原理又是什么呢,下面就来看一下。

...
.subscribeOn(Schedulers.newThread())
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())

在scheduler.scheduleDirect()的源码中,我们可以看到具体线程是如何切换的。

public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) {final Worker w = createWorker();final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);w.schedule(new Runnable() {@Overridepublic void run() {try {decoratedRun.run();} finally {w.dispose();}}}, delay, unit);return w;
}

下面run()方法中是调用了 decoratedRun.run(),decoratedRun是传入的Runnable。这里先看一下Worker是什么,它后面是调用了Worker的schedule()方法,我们先要看一下Worker是什么,它是由creatWorker()创建的,点击进去发现这是个抽象方法。需要找到它的实现类。它是Scheduler的抽象方法,需要找到具体的Scheduler。我们先看一下Schedulers.newThread(),最终会跳到NewThreadScheduler里面。

@Override
public Worker createWorker() {return new NewThreadWorker(THREAD_FACTORY);
}

点击进去,我们发现,原来这就是个Executor,只是对它做了包装,具体的细节就不仔细看了。只要知道它是通过Executor来实现多线程就行了。

private final ScheduledExecutorService executor;volatile boolean disposed;public NewThreadWorker(ThreadFactory threadFactory) {executor = SchedulerPoolFactory.create(threadFactory);
}

再来看一下 IoScheduler的createWorker()方法。

@Override
public Worker createWorker() {return new EventLoopWorker(pool.get());
}

再看一下EventLoopWorker这个类,不难发现,这是一个带有缓存的newThread()。IoScheduler()比起newThread(),就是能对 Executor 进行重用而已

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(WORKER_THREAD_FACTORY);allWorkers.add(w);return w;
}

最后看一下AndroidSchedulers.mainThread()的实现。通过一系列跳转,我们最终会跳到HandlerScheduler这个类中。

private final Handler handler;HandlerScheduler(Handler handler) {this.handler = handler;
}@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, Math.max(0L, unit.toMillis(delay)));return scheduled;
}

看到这里,有没有觉得很熟悉,没错,就是通过Handler来实现子线程和主线程的切换。最后调用的handler.postDelayed(),相信不少人在实际开发中都用过。不管怎么封装,子线程需要和主线程交互,最终还是要用到Handler的。

6 总结

至此,RxJava的源码分析就结束了。总结一下,RxJava是很容易上手的,链式的写法也让人赏心悦目。代码结构也不是很难,整体框架还是比较容易看懂的,但是里面的具体逻辑是复杂的,每行都看懂是不可能。尽管这样,我们也能从中学到很多东西,从它的源码结构中获益良多。

 
  相关解决方案