【Android】RxJava的使用（四）线程控制 —— Scheduler

前言

通过前几篇的介绍，对RxJava对模式有了必定的理解：由Observable发起事件，通过中间的处理后由Observer消费。（对RxJava还不了解的能够出门左拐）
以前的代码中，事件的发起和消费都是在同一个线程中执行，也就是说以前咱们使用的RxJava是同步的～～～
观察者模式自己的目的不就是后台处理，将处理结果回调给前台？这同步的是要哪样？因此，这篇为你们介绍RxJava的重要的概念——Scheduler

参考： 给 Android 开发者的 RxJava 详解
（本文部份内容引用自该博客）

介绍

RxJava在不指定线程的状况下，发起时间和消费时间默认使用当前线程。因此以前的作法

Observable.just(student1, student2, student2)
                //使用map进行转换，参数1：转换前的类型，参数2：转换后的类型
                .map(new Func1<Student, String>() {
                    @Override
                    public String call(Student i) {
                        String name = i.getName();//获取Student对象中的name
                        return name;//返回name
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        nameList.add(s);
                    }
                });

由于是在主线程中发起的，因此无论中间map的处理仍是Action1的执行都是在主线程中进行的。如果map中有耗时的操做，这样会致使主线程拥塞，这并非咱们想看到的。

Scheduler

Scheduler：线程控制器，能够指定每一段代码在什么样的线程中执行。
模拟一个需求：新的线程发起事件，在主线程中消费

private void rxJavaTest3() {
        Observable.just("Hello", "Word")
                .subscribeOn(Schedulers.newThread())//指定 subscribe() 发生在新的线程
                .observeOn(AndroidSchedulers.mainThread())// 指定 Subscriber 的回调发生在主线程
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, s);
                    }
                });

上面用到了subscribeOn()，和observeOn()方法来指定发生的线程和消费的线程。

• subscribeOn()：指定subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫作事件产生的线程。

• observeOn()：指定Subscriber 所运行在的线程。或者叫作事件消费的线程。

以及参数Scheduler，RxJava已经为咱们提供了一下几个Scheduler

• Schedulers.immediate()：直接在当前线程运行，至关于不指定线程。这是默认的 Scheduler。
• Schedulers.newThread()：老是启用新线程，并在新线程执行操做。
• Schedulers.io()： I/O 操做（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差很少，区别在于 io() 的内部实现是是用一个无数量上限的线程池，能够重用空闲的线程，所以多数状况下 io() 比 newThread() 更有效率。不要把计算工做放在 io() 中，能够避免建立没必要要的线程。
• Schedulers.computation()：计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操做限制性能的操做，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操做放在 computation() 中，不然 I/O 操做的等待时间会浪费 CPU。
•  AndroidSchedulers.mainThread()：它指定的操做将在 Android 主线程运行。

屡次切换线程

看完上面的介绍想必对RxJava线程的切换有了一些理解，上面只是对事件的发起和消费制定了线程。若是中间有map之类的操做呢？是否能够实现发起的线程在新线程中，map的处理在IO线程，最后的消费在主线程中。

Observable.just("Hello", "Wrold")
                .subscribeOn(Schedulers.newThread())//指定：在新的线程中发起
                .observeOn(Schedulers.io())         //指定：在io线程中处理
                .map(new Func1<String, String>() {
                    @Override
                    public String call(String s) {
                        return handleString(s);       //处理数据
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())//指定：在主线程中处理
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        show(s);                       //消费事件
                    }
                });

能够看到observeOn()被调用了两次，分别指定了map的处理的现场和消费事件show(s)的线程。

若将observeOn(AndroidSchedulers.mainThread())去掉会怎么样？不为消费事件show(s)指定线程后，show(s)会在那里执行？
其实，observeOn() 指定的是它以后的操做所在的线程。也就是说，map的处理和最后的消费事件show(s)都会在io线程中执行。
observeOn()能够屡次使用，能够随意变换线程

小结

学会线程控制后才算是真正学会了使用RxJava。RxJava的使用十分灵活，想要对其熟悉使用只有一个办法，那就是多用啦，熟能生巧。

以上有错误之处感谢指出

参考：给 Android 开发者的 RxJava 详解
（本文部份内容引用自该博客）