本身不从头介绍RxJava的用法,仅对RxJava的线程调度做出一点解说,为了节约阅读时间,先把本文得到的几条结论写到前面
- 在不指定线程的情况下,RxJava遵循线程不变的原则,即:在哪个线程调用subscribe,就在哪个线程消费;在哪个线程生产事件,就在哪个线程消费事件;
- observeOn可以调用多次,每次调用影响它直接的下级Subscriber;但是subscribeOn只能调用一次;
- Schedulers.newThread每次都会创建一个新的线程来执行任务。
- Schedulers.io(),有可能会造成内存溢出;它的原理是,当存在空闲线程时,就以先进后出的方式来查找空闲线程来执行当前任务;如果没有空闲线程,就再开启一个线程;RxJava默认会回收超过60S仍然空闲的线程池。
下面依次从实际使用和源码的角度对上述内容做出解释,涉及大量的源码阅读,慎读。
二、RxJava默认遵循线程不变的原则在不指定线程的情况下,RxJava遵循线程不变的原则,即;在哪个线程调用subscribe,就在哪个线程消费;在哪个线程生产事件,就在哪个线程消费事件。
先看一个例子。
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
object : Thread() {
override fun run() {
Log.e("yanlog","thread id:"+Thread.currentThread().name)
testRxjava(1)
}
}.start()
}
private fun testRxjava(index: Int) {
Observable.create {
Log.e("yanlog", "Observable index:$index:" + Thread.currentThread().name)
it.onNext(1)
it.onComplete()
}.subscribe({
Log.e("yanlog", "Subscriber index$index:$it:" + Thread.currentThread().name)
}, {})
}
}
观察下输出
06-01 18:45:51.887 5436 5466 E yanlog : thread id:Thread-2
06-01 18:45:51.904 5436 5466 E yanlog : Observable index:1:Thread-2
06-01 18:45:51.904 5436 5466 E yanlog : Subscriber index1:1:Thread-2
然后更改下实现,我们让observable在IO线程触发
Observable.create{ Log.e("yanlog", "Observable index:$index:" + Thread.currentThread().name) it.onNext(1) it.onComplete() }.subscribeOn(Schedulers.io()) .subscribe({ Log.e("yanlog", "Subscriber index$index:$it:" + Thread.currentThread().name) }, {})
观察下输出
06-01 18:47:06.300 5857 5911 E yanlog : thread id:Thread-2
06-01 18:47:06.325 5857 5916 E yanlog : Observable index:1:RxCachedThreadScheduler-1
06-01 18:47:06.325 5857 5916 E yanlog : Subscriber index1:1:RxCachedThreadScheduler-1
从上述的两个例子我们可以得到结论
在不指定线程的情况下,RxJava遵循线程不变的原则,即;在哪个线程调用subscribe,就在哪个线程消费;在哪个线程生产事件,就在哪个线程消费事件。
为什么会这样呢? 请看下一章,observeOn与subscribeOn
三、observeOn与subscribeOn我们先不用observeOn与subscribeOn,利用RxJava实现一个最简单的例子。
Observable.create{ Log.e("yanlog", "Observable index:$index:" + Thread.currentThread().name) it.onNext(1) it.onComplete() }.subscribe({ Log.e("yanlog", "Subscriber index$index:$it:" + Thread.currentThread().name) }, {})
我们知道,一旦我们对Observable进行subscribe,Observable中的代码就会执行起来,具体怎么执行呢?
先看下相关源码
public staticObservable create(ObservableOnSubscribe source) { //实际是创建一个ObservableCreate对象 return RxJavaPlugins.onAssembly(new ObservableCreate (source)); } public final class ObservableCreate extends Observable { .... public final void subscribe(Observer super T> observer) { //当一个Observable被订阅后,实际上就执行subscribeActual方法 subscribeActual(observer); ... } @Override protected void subscribeActual(Observer super T> observer) { ... //最终会执行到ObservableOnSubscribe的的subscribe方法中,我们在ObservableOnSubscribe中去执行onNext、onComplete、onError等方法 source.subscribe(parent); ... } }
根据上面我们得到了RxJava的两条事件流,并且可以看到,如果没有设置Schedule,则不会有切换线程的动作,即在哪个线程调用subscribe,就在哪个线程消费;在哪个线程生产事件,就在哪个线程消费事件。
此时,我们先看subscribeOn方法
public final ObservablesubscribeOn(Scheduler scheduler) { //这里创建ObservableSubscribeOn对象 return RxJavaPlugins.onAssembly(new ObservableSubscribeOn (this, scheduler)); } public final class ObservableSubscribeOn extends AbstractObservableWithUpstream { final Scheduler scheduler; public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) { super(source); //我们传入Scheduler调度方法 this.scheduler = scheduler; } @Override public void subscribeActual(final Observer super T> observer) { final SubscribeOnObserver parent = new SubscribeOnObserver (observer); //从这里可以看到,我们在scheduler上去执行,也就是在这里完成了线程的切换。 parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent))); } }
从上面代码可以看到,在ObservableSubscribeOn的subscribeActual方法中完成了线程的切换,并且因为源Observer只有“一个”,所以只有离Observer最近的Scheduler才生效。
接下来我们来看observeOn方法
public final ObservableobserveOn(Scheduler scheduler, boolean delayError, int bufferSize) { //这里实际创建了ObservableObserveOn对象 return RxJavaPlugins.onAssembly(new ObservableObserveOn (this, scheduler, delayError, bufferSize)); } public final class ObservableObserveOn extends AbstractObservableWithUpstream { final Scheduler scheduler; public ObservableObserveOn(ObservableSource source, Scheduler scheduler, boolean delayError, int bufferSize) { super(source); this.scheduler = scheduler; } @Override protected void subscribeActual(Observer super T> observer) { Scheduler.Worker w = scheduler.createWorker(); //这里可以看到,对observer封装了ObserveOnObserver source.subscribe(new ObserveOnObserver (observer, w, delayError, bufferSize)); } } static final class ObserveOnObserver extends BasicIntQueueDisposable implements Observer , Runnable { @Override public void onNext(T t) { //这里将产生的值放到队列中 queue.offer(t); schedule(); } void schedule() { //schedule中利用worker来执行runnable,实际完成了切成的切换 worker.schedule(this); } void runnable() { for (;;) { //这里将值传递给下一级 v = q.poll(); a.onNext(v); } }
如上面源码,observeOn实际上在ObserveOnObserver的schedule方法中完成了线程的切换,并且这种切换对下一级Observer有效。
四、 Schedulers.newThreadSchedulers.newThread每次都会创建一个新的线程来执行任务。
先看一个例子。
class MainActivity : AppCompatActivity() {
@RequiresApi(Build.VERSION_CODES.P)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
for (i in 0..9) {
testRxjava(i)
}
}
private fun testRxjava(index:Int) {
Observable.create {
Log.e("yanlog", "Observable index:$index:" + Thread.currentThread().name)
for (i in 0..9) {
Thread.sleep(1000)
it.onNext(i)
}
it.onComplete()
}.subscribeOn(Schedulers.newThread())
.observeOn(Schedulers.newThread())
.subscribe({
Log.e("yanlog", "Subscriber index$index:$it:" + Thread.currentThread().name)
}, {})
}
}
看下他的打印
05-22 19:47:14.052 28881 28978 E yanlog : Observable index:0:RxNewThreadScheduler-1
05-22 19:47:14.052 28881 28979 E yanlog : Observable index:1:RxNewThreadScheduler-2
05-22 19:47:14.052 28881 28980 E yanlog : Observable index:2:RxNewThreadScheduler-3
05-22 19:47:14.052 28881 28981 E yanlog : Observable index:3:RxNewThreadScheduler-4
05-22 19:47:14.052 28881 28982 E yanlog : Observable index:4:RxNewThreadScheduler-5
05-22 19:47:14.052 28881 28983 E yanlog : Observable index:5:RxNewThreadScheduler-6
05-22 19:47:14.052 28881 28984 E yanlog : Observable index:6:RxNewThreadScheduler-7
05-22 19:47:14.052 28881 28985 E yanlog : Observable index:7:RxNewThreadScheduler-8
05-22 19:47:14.053 28881 28986 E yanlog : Observable index:8:RxNewThreadScheduler-9
05-22 19:47:14.053 28881 28987 E yanlog : Observable index:9:RxNewThreadScheduler-10
05-22 19:47:15.053 28881 29030 E yanlog : Subscriber index3:0:RxNewThreadScheduler-14
05-22 19:47:15.053 28881 29033 E yanlog : Subscriber index4:0:RxNewThreadScheduler-15
05-22 19:47:15.053 28881 29031 E yanlog : Subscriber index1:0:RxNewThreadScheduler-12
05-22 19:47:15.053 28881 29029 E yanlog : Subscriber index2:0:RxNewThreadScheduler-11
05-22 19:47:15.054 28881 29032 E yanlog : Subscriber index0:0:RxNewThreadScheduler-13
05-22 19:47:15.054 28881 29034 E yanlog : Subscriber index5:0:RxNewThreadScheduler-16
05-22 19:47:15.054 28881 29035 E yanlog : Subscriber index7:0:RxNewThreadScheduler-18
05-22 19:47:15.054 28881 29036 E yanlog : Subscriber index8:0:RxNewThreadScheduler-19
05-22 19:47:15.054 28881 29038 E yanlog : Subscriber index9:0:RxNewThreadScheduler-20
05-22 19:47:15.054 28881 29037 E yanlog : Subscriber index6:0:RxNewThreadScheduler-17
05-22 19:47:16.053 28881 29035 E yanlog : Subscriber index7:1:RxNewThreadScheduler-18
//忽略部分打印
从上面打印可以看出,每次调用Schedulers.newThread,都会创建一个新的线程来执行
我们接着从源码的角度来理解下。
当任务开始执行时,RxJava会首先通过调用createWorker来创建一个Worker来执行,就像先创建一个工人来执行一样。
public final class NewThreadScheduler extends Scheduler {
...
@NonNull
@Override
public Worker createWorker() {
return new NewThreadWorker(threadFactory); //创建一个新的Worker
}
}
public class NewThreadWorker extends Scheduler.Worker implements Disposable {
private final ScheduledExecutorService executor;
volatile boolean disposed;
public NewThreadWorker(ThreadFactory threadFactory) {
//当创建一个NewThreadWorker时,会创建一个新的核心数为1的线程池
executor = SchedulerPoolFactory.create(threadFactory);
}
public Disposable scheduleDirect(final Runnable run, long delayTime, TimeUnit unit) {
...
//将任务提交到线程池中执行
f = executor.submit(task);
}
return sr;
}
//当任务执行完,会关闭这个worker,同时也就关闭了线程池
public void shutdown() {
if (!disposed) {
disposed = true;
executor.shutdown();
}
}
}
从上面源码可以解释出,每次Schedulers.newThread确实是每次都会创建一个新的线程来执行。
五、Schedulers.ioSchedulers.io(),有可能会造成内存溢出;它的原理是,当存在空闲线程时,就以先进后出的方式获取空闲线程来执行当前任务;如果没有空闲线程,就再开启一个线程;RxJava默认会回收超过60S仍然空闲的线程池。
看下以下的例子
class MainActivity : AppCompatActivity() {
@RequiresApi(Build.VERSION_CODES.P)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
object : Thread() {
override fun run() {
for (i in 0..9) {
//我们每隔500ms,创建一个Observer,每隔Observer理论上1s内会执行完毕
testRxjava(i)
Thread.sleep(500)
}
}
}.start()
}
private fun testRxjava(index: Int) {
Observable.create {
Log.e("yanlog", "Observable index:$index:" + Thread.currentThread().name)
Thread.sleep(1000)
it.onNext(1)
it.onComplete()
}.subscribeOn(Schedulers.io())
.observeOn(Schedulers.io())
.subscribe({
Log.e("yanlog", "Subscriber index$index:$it:" + Thread.currentThread().name)
}, {})
}
}
在上述例子中,我们我们每隔500ms,创建一个Observer,每隔Observer理论上1s内会执行完毕。
看下执行结果
05-22 20:07:15.279 2250 2432 E yanlog : Observable index:0:RxCachedThreadScheduler-1
//因为当前没有空闲线程,所以下面会依次创建新的线程来执行
05-22 20:07:15.780 2250 2454 E yanlog : Observable index:1:RxCachedThreadScheduler-2
05-22 20:07:16.280 2250 2463 E yanlog : Subscriber index0:1:RxCachedThreadScheduler-3
//在生成第三次Observer的时候,线程3已经执行完毕,所以这里复用了线程3,线程1放在了对应的Subscriber中。所以这次查找可用线程,是遵循先进后出的方式来执行的。
05-22 20:07:16.280 2250 2463 E yanlog : Observable index:2:RxCachedThreadScheduler-3
05-22 20:07:16.781 2250 2471 E yanlog : Observable index:3:RxCachedThreadScheduler-5
05-22 20:07:16.781 2250 2470 E yanlog : Subscriber index1:1:RxCachedThreadScheduler-4
05-22 20:07:17.282 2250 2432 E yanlog : Subscriber index2:1:RxCachedThreadScheduler-1
05-22 20:07:17.282 2250 2470 E yanlog : Observable index:4:RxCachedThreadScheduler-4
05-22 20:07:17.783 2250 2432 E yanlog : Observable index:5:RxCachedThreadScheduler-1
05-22 20:07:17.784 2250 2494 E yanlog : Subscriber index3:1:RxCachedThreadScheduler-6
05-22 20:07:18.284 2250 2494 E yanlog : Observable index:6:RxCachedThreadScheduler-6
05-22 20:07:18.285 2250 2454 E yanlog : Subscriber index4:1:RxCachedThreadScheduler-2
05-22 20:07:18.785 2250 2454 E yanlog : Observable index:7:RxCachedThreadScheduler-2
05-22 20:07:18.786 2250 2463 E yanlog : Subscriber index5:1:RxCachedThreadScheduler-3
05-22 20:07:19.285 2250 2471 E yanlog : Subscriber index6:1:RxCachedThreadScheduler-5
05-22 20:07:19.286 2250 2463 E yanlog : Observable index:8:RxCachedThreadScheduler-3
05-22 20:07:19.787 2250 2471 E yanlog : Observable index:9:RxCachedThreadScheduler-5
05-22 20:07:19.787 2250 2470 E yanlog : Subscriber index7:1:RxCachedThreadScheduler-4
05-22 20:07:20.288 2250 2432 E yanlog : Subscriber index8:1:RxCachedThreadScheduler-1
05-22 20:07:20.789 2250 2494 E yanlog : Subscriber index9:1:RxCachedThreadScheduler-6
那为什么说Schecriber.io可能会造成内存溢出呢?如果我们假设把没给Observer的执行时间设置的特别长,如30分钟,就会发现系统会创建非常多的线程,造成内存溢出(篇幅原因,这里不展示代码了,有兴趣可以自己测试下)。
我们阅读下Subscriber.io的源码。
public final class IoScheduler extends Scheduler {
...
public Worker createWorker() {
//当执行任务的时候,会首先创建一个EventLoopWorker来执行任务。
return new EventLoopWorker(pool.get());
}
static final class EventLoopWorker extends Scheduler.Worker implements Runnable {
...
EventLoopWorker(CachedWorkerPool pool) {
this.pool = pool;
}
public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
...
//从Worker池中获取一个Worker来执行当前的任务,所以重点就在CachedWorkerPoll.get方法
return pool.get().scheduleActual(action, delayTime, unit, tasks);
}
}
static final class CachedWorkerPool implements Runnable {
private final long keepAliveTime;
private final ConcurrentLinkedQueue expiringWorkerQueue;
final CompositeDisposable allWorkers;
private final ScheduledExecutorService evictorService;
private final Future> evictorTask;
private final ThreadFactory threadFactory;
CachedWorkerPool(long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory) {
this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0L;
this.expiringWorkerQueue = new ConcurrentLinkedQueue();
this.allWorkers = new CompositeDisposable();
this.threadFactory = threadFactory;
ScheduledExecutorService evictor = null;
Future> task = null;
if (unit != null) {
evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
task = evictor.scheduleWithFixedDelay(this, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS);
}
evictorService = evictor;
evictorTask = task;
}
@Override
public void run() {
evictExpiredWorkers();
}
ThreadWorker get() {
//expiringWorkerQueue存放着系统所有空闲的Worker,如果不为空,则从队尾取出一个空闲的Worker来执行任务
while (!expiringWorkerQueue.isEmpty()) {
ThreadWorker threadWorker = expiringWorkerQueue.poll();
if (threadWorker != null) {
return threadWorker;
}
}
//如果没有空闲的Worker,则会会直接创建一个Worker,每一个Worker中都会开启一个线程。这也是会导致内存溢出的原因。
ThreadWorker w = new ThreadWorker(threadFactory);
allWorkers.add(w);
return w;
}
void release(ThreadWorker threadWorker) {
//当一个Worker被释放时,则会进入到空闲状态,此时会把这个Worker放到队尾
expiringWorkerQueue.offer(threadWorker);
}
void evictExpiredWorkers() {
//系统会定期清理空闲的worker,目前清理时间是60s,如果60S内Worker没有被分配新的任务,则被清理掉(好可怜的打工人)
if (!expiringWorkerQueue.isEmpty()) {
long currentTimestamp = now();
for (ThreadWorker threadWorker : expiringWorkerQueue) {
if (threadWorker.getExpirationTime() <= currentTimestamp) {
if (expiringWorkerQueue.remove(threadWorker)) {
allWorkers.remove(threadWorker);
}
}
}
}
}
}
}
如果要想避免Subscriber.io造成的内存泄漏问题,可以使用Schedulers.COMPUTATION,他开启一个大小为CPU核心数的固定size的线程池,从而避免因为创建IO过多造成的泄漏问题,篇幅原因这里不展开看他的源码。有兴趣可以自行研究。



