RxJava2（五）线程调度器Scheduler

线程调度器Scheduler

RxJava是一个为异步编程而实现的库，但异步也存在线程安全问题，比如，那些操作需要在前台线程，那些操作又需要在后台线程等等。而Scheduler就是这样一个线程调度器，可以在线程间来回切换。理想的操作是Observable发射数据流，操作符在后台线程处理数据，Obverser在前台线程接受并响应数据。

Scheduler可调度的线程有：

· single：定长为1的线程池（SingledThreadExecutor），复用这个线程。
· newThread：启动一条新线程，并在其中进行操作。
· computation：固定线程池（FixedThreadPool(N)），大小为CPU数，适合与密集型计算。
· io：无数量上限线程池（CachedThreadPool），可复用空闲线程，适合I/O操作，文件读写，网络信息交互等。
· trampoline：直接在当前线程优先执行。
· from：自定义调度器。
· AndroidSchedulers.mainThread 主线程。

切换线程方法：

subscribeOn(Scheduler) 针对上游，指定处理数据在特定的线程调度器。若多次调用，只有第一次调用有用。
observeOn(Scheduler) 针对下游，指定下游操作在特定的线程调度器。若多次调用，每次都有用，来回切换。

private void init() {
        mContext = getApplicationContext();
        Observable.just("hello")
                .subscribeOn(Schedulers.single())
                .map(new Function<String, String>() {
                    @Override
                    public String apply(String s) {
                        s = s + "world";
                        showLog(mContext, "single", s);
                        return s;
                    }
                }).observeOn(Schedulers.io())
                .map(new Function<String, String>() {
                    @Override
                    public String apply(String s) {
                        s = s.toUpperCase();
                        showLog(mContext, "io", s);
                        return s;
                    }
                }).subscribeOn(Schedulers.computation())
                .map(new Function<String, String>() {
                    @Override
                    public String apply(String s) {
                        s = s + "你好";
                        showLog(mContext, "computation", s);
                        return s;
                    }
                }).observeOn(Schedulers.newThread())
                .map(new Function<String, String>() {
                    @Override
                    public String apply(String s) {
                        s = s + "世界！";
                        showLog(mContext, "newThread", s);
                        return s;
                    }
                }).observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        showLog(mContext, "mainThread", s);
                    }
                });
    }

    private void showLog(Context context, String whichScheduler, String value) {
        int processId = Process.myPid();
        Log.d(TAG, "所在线程:" + Thread.currentThread().getName() +
                "  调度器:" + whichScheduler + "  输出值:" + value);
    }

输出结果：

	所在线程:RxSingleScheduler-1  调度器:single  输出值:helloworld
	所在线程:RxCachedThreadScheduler-1  调度器:io  输出值:HELLOWORLD
   	所在线程:RxCachedThreadScheduler-1  调度器:computation  输出值:HELLOWORLD你好
	所在线程:RxNewThreadScheduler-1  调度器:newThread  输出值:HELLOWORLD你好世界！
	所在线程:main  调度器:mainThread  输出值:HELLOWORLD你好世界！

可以看出再次调用subscribeOn(Schedulers.computation() 并没有切换线程。

TestScheduler

专门用于测试的调度器，非线程安全。只有被调用了时间才会启动。用于测试一些不引入真实并发性，允许推进虚拟时间的调度器。当未调用时间，调度器什么也不做，相当于所有任务都未执行。当调用时间后，启动相当于一个时间流，好像他们本来就已经启动好久了，你直接移动虚拟时间到这个时间流的任意时间节点，做操作就好。

1.advanceTimeTo 将调度器的始终移动到某个时刻。

private void test() {
        TestScheduler testScheduler = new TestScheduler();
        testScheduler.createWorker().schedule(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "run: 立即执行");
            }
        });

        testScheduler.createWorker().schedule(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "run: 延迟10秒执行");
            }
        },10,TimeUnit.MILLISECONDS);

        testScheduler.createWorker().schedule(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "run: 延迟20秒执行");
            }
        },20,TimeUnit.MILLISECONDS);
        //调用后，调度器启动，移动到10秒位置
        testScheduler.advanceTimeTo(10,TimeUnit.SECONDS);
        Log.d(TAG, "移动虚拟时间后，当前时间 " + testScheduler.now(TimeUnit.SECONDS));
    }

输出结果：
run: 立即执行
run: 延迟10秒执行
run: 延迟20秒执行
移动虚拟时间后，当前时间 10

由于调用advanceTimeTo(10,TimeUnit.SECONDS) 相当于所有任务都准备好了，直接移动虚拟时间到任意时间节点。

2.advanceBy 在原来基础上移动给定时间值。

3.triggerAction 不会修改时间，它执行计划要启动，但当前还未启动的任务。

private void test() {
        TestScheduler testScheduler = new TestScheduler();
        testScheduler.createWorker().schedule(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "run: 立即执行");
            }
        });

        testScheduler.createWorker().schedule(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "run: 延迟10秒执行");
            }
        },10,TimeUnit.MILLISECONDS);

        testScheduler.createWorker().schedule(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "run: 延迟20秒执行");
            }
        },20,TimeUnit.MILLISECONDS);
        Log.d(TAG, "当前时间 " + testScheduler.now(TimeUnit.SECONDS)); 
        testScheduler.triggerActions();
    }

输出结果：
当前时间 0
run: 立即执行

由于未调用advanceTimeTo和advanceBy，不启动调度器。因此直接执行到打印log “当前时间”，又因调用 testScheduler.triggerActions()，所以执行第一个计划执行而又未执行的worker线程。

增加调用advanceTimeTo

private void test() {
        TestScheduler testScheduler = new TestScheduler();
        testScheduler.createWorker().schedule(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "run: 立即执行");
            }
        });

        testScheduler.createWorker().schedule(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "run: 延迟10秒执行");
            }
        },10,TimeUnit.MILLISECONDS);

        testScheduler.createWorker().schedule(new Runnable() {
            @Override
            public void run() {
                Log.d(TAG, "run: 延迟20秒执行");
            }
        },20,TimeUnit.MILLISECONDS);
        Log.d(TAG, "当前时间 " + testScheduler.now(TimeUnit.SECONDS));
        //调用后，调度器启动，移动到10秒位置
        testScheduler.advanceTimeTo(20,TimeUnit.SECONDS);
        Log.d(TAG, "移动虚拟时间后，当前时间 " + testScheduler.now(TimeUnit.SECONDS));
        testScheduler.triggerActions();
    }

输出结果：
当前时间 0
run: 立即执行
run: 延迟10秒执行
run: 延迟20秒执行
移动虚拟时间后，当前时间 20

可以看出当调用advanceTimeTo(20,TimeUnit.SECONDS)后，调度器被启动。当调用triggerActions()时，因所有worker线程都被执行，所以没有还没启动的任务，不打印结果。