栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

RxJava线程调度浅析

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

RxJava线程调度浅析

一、结论

本身不从头介绍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 static  Observable create(ObservableOnSubscribe source) {
	//实际是创建一个ObservableCreate对象
    return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}

public final class ObservableCreate extends Observable {
 ....
 
    public final void subscribe(Observer observer) {
    	//当一个Observable被订阅后,实际上就执行subscribeActual方法
        subscribeActual(observer);
        ...
    }
    
    @Override
    protected void subscribeActual(Observer observer) {
        ...
        //最终会执行到ObservableOnSubscribe的的subscribe方法中,我们在ObservableOnSubscribe中去执行onNext、onComplete、onError等方法
        source.subscribe(parent);
        ...
    }
}

根据上面我们得到了RxJava的两条事件流,并且可以看到,如果没有设置Schedule,则不会有切换线程的动作,即在哪个线程调用subscribe,就在哪个线程消费;在哪个线程生产事件,就在哪个线程消费事件。

此时,我们先看subscribeOn方法

public final Observable subscribeOn(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 observer) {
        final SubscribeOnObserver parent = new SubscribeOnObserver(observer);
        //从这里可以看到,我们在scheduler上去执行,也就是在这里完成了线程的切换。
        parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    }
}

从上面代码可以看到,在ObservableSubscribeOn的subscribeActual方法中完成了线程的切换,并且因为源Observer只有“一个”,所以只有离Observer最近的Scheduler才生效。

接下来我们来看observeOn方法

public final Observable observeOn(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 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.newThread

Schedulers.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.io

Schedulers.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过多造成的泄漏问题,篇幅原因这里不展开看他的源码。有兴趣可以自行研究。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/949459.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号