调度器Schedulers

调度器Schedulers
    如果你想给Observable操作符链添加多线程功能，你可以指定操作符在特定的调度器上执行。某些ReactiveX的Observable操作符有一些变体，他们可以接受一个Scheduler参数。
    这个参数指定操作符将他们的部分或者全部任务放在一个特定的调度器上执行。Scheduler(线程调度器)赋予了RxJava简洁明了的的异步操作，可以说是Rxjava中最重要的体现之一。
    使用Observable发射数据流，Observer接收响应数据流，以及Operators加工数据流均是在同一个线程中，实现出来的是一个同步的函数响应式，但是函数响应式的实际应用却不是这样的，
    大部分都是后台处理，前台响应的一个过程，Observable生成发射数据流，以及Operators加工数据流都是在后台线程中进行，而Observer在前台线程中接收并响应数据。
    总体来说,Schedulers(线程调度器)可以让RxJava的线程切换变得简单明了，即使是在处理逻辑十分复杂，他任然能够保持简单明了。

    使用ObserveOn和SubscribeOn操作符，你可以让Observable在一个特定的调度器上执行，ObserveOn只是一个Observable在一个特定的调度器上调用观察者的onNext(),onError()和onComplete()方法。
    SubscribeOn更进一步，它指示Observable将全部的处理过程(包括发射数据和通知)放在特定的调度器上执行。

    Observable<T> subscribeOn(Scheduler scheduler)通过接受一个Scheduler参数,来指定对数据的处理进行运行在特定的线程调度器中Scheduler上，如果多次设定，则只有一次起作用。
    Observable<T> observeOn(Scheduler scheduler)同样接受一个Scheduler参数，来指定下游操作运行在特定的线程调度器Scheduler上，如果多次设定，每次都起作用。

调度器的种类：针对于Rxjava 2.x版本来说，有以下几种：
Schedulers.computation() : 用于cpu密集型计算任务，即不会被被I/O等操作限制性能的耗时操作，例如XML，JSON文件的解析，Bitmap图片的压缩取样等，
具有固定的线程池，大小为CPU核数，不可以用于IO操作，因为IO操作的等待时间会浪费cpu

Schedulers.from(@NonNull Excutor excutor):指定一个线程调度器，由此调度器来控制任务的执行策略。

Schedulers.io():用于IO密集型的操作，例如写磁盘操作，查询数据库，网络访问，具有线程缓存机制，在此调度器接收到任务之后，先检查线程缓存池中是否有空闲的线程可用，如果有，复用，如果没有则 创建新的线程，并将其加入到线程池中，如果每次都没有空闲的线程使用，可以无上限的创建线程。

Schedulers.newThread(): 在每执行一个任务时创建一个新的线程，不具有线程缓存机制，由于创建一个线程比起复用一个线程更加耗时耗力，虽然使用Schedulers.io()的地方都可以使用Schedulers.newThread(),但是总体上的Schedulers.newThread()的效率没有Schedulers.io()的高。

Schedulers.trampoline():在当前线程立即执行任务，如果当前线程有任务在执行，则会将其暂停下来，等插入进来的任务执行完成之后，再将未完成的任务接着执行。

Schedulers.single():拥有一个线程单例，所有的任务都在这一个线程中执行，当此线程中有任务在执行的时候其他任务将按照队列先进先出的顺序依次执行。

AndroidSchedulers.mainThread():在Andriod UI线程中执行任务，属于Android的专属定制。

注意：在Rxjava 2.x版本中，废弃了1.x版本Schedulers.immediate(),在1.x中，Schedulers.immediate的作用是在当前线程中立即执行任务，功能等同于Rxjava中的2.x版本中的Schedulers.trampoline(),
而在Schedulers.trampoline()在1.x版本的时候，作用是：当其他排队的任务执行完成之后，在当前线程排队开始执行接收到的任务，有点像2.x版本的Schedulers.single(),
但是也不完全相同，因为Schedulers.single()不是在当前线程而是在一个线程单例中排队执行任务。

    @Test
    public void testScheduler() {

        Worker worker = Schedulers.newThread().createWorker();
        worker.schedule(() -> System.out.println("111111"));

        boolean disposed = worker.isDisposed();
        System.out.println(" value is:" + disposed);
    }

    @Test
    public void testScheduler2() {
        Observable.create(new ObservableOnSubscribe<String>() {

            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                for (int i = 0; i < 5; i++) {
                    System.out.println("发射线程：" + Thread.currentThread().getName() + " ---->发射: " + i);
//                    Thread.sleep(100L);
                    emitter.onNext("===>" + i);
                }
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.io())
        .observeOn(Schedulers.computation())
        .subscribe(new Consumer<String>() {

            @Override
            public void accept(String t) throws Exception {
                System.out.println("接收线程：" + Thread.currentThread().getName() + " ---->接收: " + t);
            }

        });
    }
    
    @Test
    public void testScheduler3() {
        Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                for(int i = 0; i< 60;i++) {
                    System.out.println("发射线程：" + Thread.currentThread().getName() + " --> 发射：" + i);
                    e.onNext(i);
                }
                e.onComplete();
            }
        }).subscribeOn(Schedulers.io())
        .observeOn(Schedulers.trampoline())
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer t) throws Exception {
                System.out.println("接收线程：" + Thread.currentThread().getName() + " --> 接收：" + t);
            }
        });
    }
    
    
    @Test
    public void testScheduler4(){
        Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                for(int i =0;i<10;i++) {
                    System.out.println("发射线程：" + Thread.currentThread().getName() + " ---> 发射:" + i);
//                    Thread.sleep(100);
                    emitter.onNext(i);
                }
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.single())
        .observeOn(Schedulers.single())
        .map(new Function<Integer, Integer>() {

            @Override
            public Integer apply(Integer value) throws Exception {
                System.out.println("处理线程：" + Thread.currentThread().getName() + " ---> 处理:" + value);
                return value;
            }
        })
        .observeOn(Schedulers.single())
        .subscribe(new Consumer<Integer>() {

            @Override
            public void accept(Integer t) throws Exception {
                System.out.println("接收线程：" + Thread.currentThread().getName() + " ---> 接收:" + t);
            }
        });
    }