移动架构40_RxAndroid三（线程控制Scheduler）

Android移动架构汇总​​​​​​​
移动架构38_RxJava一（简单调用）
移动架构39_RxAndroid二（变换调用：map、flatMap、lift、compose）
移动架构40_RxAndroid三（线程控制Scheduler）
移动架构41_Retrofit+RxJava快速集成
#1 定义Scheduler
在RxJava 中，Scheduler ——调度器，相当于线程控制器，RxJava 通过它来指定每一段代码应该运行在什么样的线程。
● 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 主线程运行
#2 使用Scheduler
subscribeOn()指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程；当使用了多个 subscribeOn() 的时候，只有第一个 subscribeOn() 起作用。
observeOn():指定 Subscriber 所运行在的线程。或者叫做事件消费的线程，通常我们都是在Subscriber中进行操作，所以用observeOn（）先去指定下一个Subscriber 的线程，就能够满足大部分需求。

#3 Demo

int drawableRes = ...;
ImageView imageView = ...;
Observable.create(new OnSubscribe<Drawable>() {
    @Override
    public void call(Subscriber<? super Drawable> subscriber) {
        Drawable drawable = getTheme().getDrawable(drawableRes));
        subscriber.onNext(drawable);
        subscriber.onCompleted();
    }
})
.subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
.observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
.subscribe(new Observer<Drawable>() {
    @Override
    public void onNext(Drawable drawable) {
        imageView.setImageDrawable(drawable);
    }

    @Override
    public void onCompleted() {
    }

    @Override
    public void onError(Throwable e) {
        Toast.makeText(activity, "Error!", Toast.LENGTH_SHORT).show();
    }
});

那么，加载图片将会发生在 IO 线程，而设置图片则被设定在了主线程。这就意味着，即使加载图片耗费了时间，也不会造成丝毫界面的卡顿。

#4 线程的自由控制
可以利用 subscribeOn() 结合 observeOn() 来实现线程控制，让事件的产生和消费发生在不同的线程。
问：能不能多切换几次线程？
答案是：能。因为 observeOn() 指定的是 Subscriber 的线程，而这个 Subscriber 并不是（严格说应该为『不一定是』，但这里不妨理解为『不是』）subscribe() 参数中的 Subscriber ，而是 observeOn() 执行时的当前 Observable 所对应的 Subscriber ，即它的直接下级 Subscriber 。
即，observeOn() 指定的是它之后的操作所在的线程。因此如果有多次切换线程的需求，只要在每个想要切换线程的位置调用一次 observeOn() 即可。上代码：

Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.newThread())
    .map(mapOperator) // 新线程，由 observeOn() 指定
    .observeOn(Schedulers.io())
    .map(mapOperator2) // IO 线程，由 observeOn() 指定
    .observeOn(AndroidSchedulers.mainThread) 
    .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定

如上，通过 observeOn() 的多次调用，程序实现了线程的多次切换。
不过，不同于 observeOn() ， subscribeOn() 的位置放在哪里都可以，但它是只能调用一次的。

#5 Scheduler 的原理

subscribeOn() 和 observeOn() 都做了线程切换的工作，不同的是：
（1）subscribeOn() 的线程切换发生在 OnSubscribe 中，即在它通知上一级 OnSubscribe 时，这时事件还没有开始发送，因此 subscribeOn() 的线程控制可以从事件发出的开端就造成影响；
（2）observeOn() 的线程切换则发生在它内建的 Subscriber 中，即发生在它即将给下一级 Subscriber 发送事件时，因此 observeOn() 控制的是它后面的线程。

#6 doOnSubscribe()显示加载进度框
Observable.doOnSubscribe() 和 Subscriber.onStart() 同样是在 subscribe()调用后而且在事件发送前执行，但区别在于它可以指定线程。默认情况下， doOnSubscribe() 执行在 subscribe() 发生的线程；而如果在 doOnSubscribe() 之后有 subscribeOn() 的话，它将执行在离它最近的 subscribeOn() 所指定的线程。

Observable.just("imgurl")
                .subscribeOn(Schedulers.io())
                .subscribeOn(AndroidSchedulers.mainThread())
                .doOnSubscribe(new Action0() {
                    @Override
                    public void call() {
                        //第二个subscribeOn对doOnSubscribe影响，指定主线程
                    }
                })
                .map(new Func1<String, Bitmap>() {
                    @Override
                    public Bitmap call(String s) {
                        //第一个subscribeOn指定io线程
                        return BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher);
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Bitmap>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Bitmap bitmap) {
                        //observeOn指定主线程
                    }
                });

如上，在 doOnSubscribe()的后面跟一个 subscribeOn() ，就能指定准备工作的线程了。
当然也可以用observeOn实现

 Observable.just("img_url")
                 .observeOn(AndroidSchedulers.mainThread())
                 .map(new Func1<String, String>() {
                     @Override
                     public String call(String s) {
                        //observeOn控制在主线程
                         Log.i(TAG, ">>> Func1 thread11=" + Thread.currentThread().getId());
                         return  s;
                     }
                 }).observeOn(Schedulers.io())
                 .map(new Func1<String, Bitmap>() {
                     @Override
                     public Bitmap call(String s) {
                         //observeOn控制在子线程
                         Log.i(TAG, ">>> Func1 thread22=" + Thread.currentThread().getId());
                         return BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher);
                     }
                 }).observeOn(AndroidSchedulers.mainThread())
                 .subscribe(new Subscriber<Bitmap>() {
                     @Override
                     public void onCompleted() {

                     }

                     @Override
                     public void onError(Throwable e) {

                     }

                     @Override
                     public void onNext(Bitmap bitmap) {
                         //observeOn控制在主线程
                         Log.i(TAG, ">>> Func1 thread33=" + Thread.currentThread().getId());
                     }
                 });