RxJava 线程模型分析

RxJava的被观察者在使用操作符时可以利用线程调度器--Scheduler来切换线程，例如

        Observable.just("aaa","bbb")
                .observeOn(Schedulers.newThread())
                .map(new Function() {
                    @Override
                    public String apply(@NonNull String s) throws Exception {

                        return s.toUpperCase();
                    }
                })
                .subscribeOn(Schedulers.single())
                .observeOn(Schedulers.io())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {

                        System.out.println(s);
                    }
                });

被观察者(Observable、Flowable...)发射数据流之后，其操作符可以在不同的线程中加工数据流，最后被观察者在前台线程中接受并响应数据。

下图不同的箭头颜色表示不同的线程。

schedulers.png

一. 线程调度器

Schedulers 是一个静态工厂类，通过分析Schedulers的源码可以看到它有多种不同类型的Scheduler。下面是Schedulers的各个工厂方法。

computation()用于CPU密集型的计算任务，但并不适合于IO操作。

    @NonNull
    public static Scheduler computation() {
        return RxJavaPlugins.onComputationScheduler(COMPUTATION);
    }

io()用于IO密集型任务，支持异步阻塞IO操作，这个调度器的线程池会根据需要增长。对于普通的计算任务，请使用Schedulers.computation()。

    @NonNull
    public static Scheduler io() {
        return RxJavaPlugins.onIoScheduler(IO);
    }

trampoline()在RxJava2中跟RxJava1的作用是不同的。在RxJava2中表示立即执行，如果当前线程有任务在执行，则会将其暂停，等插入进来的新任务执行完之后，再将原先未完成的任务接着执行。在RxJava1中表示在当前线程中等待其他任务完成之后，再执行新的任务。

    @NonNull
    public static Scheduler trampoline() {
        return TRAMPOLINE;
    }

newThread()为每个任务创建一个新线程。

    @NonNull
    public static Scheduler newThread() {
        return RxJavaPlugins.onNewThreadScheduler(NEW_THREAD);
    }

single()拥有一个线程单例，所有的任务都在这一个线程中执行，当此线程中有任务执行时，它的任务们将会按照先进先出的顺序依次执行。

    @NonNull
    public static Scheduler single() {
        return RxJavaPlugins.onSingleScheduler(SINGLE);
    }

除此之外，还支持自定义的Executor来作为调度器。

    @NonNull
    public static Scheduler from(@NonNull Executor executor) {
        return new ExecutorScheduler(executor);
    }

RxJava 线程模型.png

Scheduler是RxJava的线程任务调度器，Worker是线程任务的具体执行者。从Scheduler源码可以看到，Scheduler在scheduleDirect()、schedulePeriodicallyDirect()方法中创建了Worker，然后会分别调用worker的schedule()、schedulePeriodically()来执行任务。

    public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
        final Worker w = createWorker();

        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        DisposeTask task = new DisposeTask(decoratedRun, w);

        w.schedule(task, delay, unit);

        return task;
    }

    public Disposable schedulePeriodicallyDirect(@NonNull Runnable run, long initialDelay, long period, @NonNull TimeUnit unit) {
        final Worker w = createWorker();

        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        PeriodicDirectTask periodicTask = new PeriodicDirectTask(decoratedRun, w);

        Disposable d = w.schedulePeriodically(periodicTask, initialDelay, period, unit);
        if (d == EmptyDisposable.INSTANCE) {
            return d;
        }

        return periodicTask;
    }

Worker也是一个抽象类，从上图可以看到每一种Scheduler会对应一种具体的Worker。

    public abstract static class Worker implements Disposable {

        public Disposable schedule(@NonNull Runnable run) {
            return schedule(run, 0L, TimeUnit.NANOSECONDS);
        }

        public abstract Disposable schedule(@NonNull Runnable run, long delay, @NonNull TimeUnit unit);

        public Disposable schedulePeriodically(@NonNull Runnable run, final long initialDelay, final long period, @NonNull final TimeUnit unit) {
            final SequentialDisposable first = new SequentialDisposable();

            final SequentialDisposable sd = new SequentialDisposable(first);

            final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

            final long periodInNanoseconds = unit.toNanos(period);
            final long firstNowNanoseconds = now(TimeUnit.NANOSECONDS);
            final long firstStartInNanoseconds = firstNowNanoseconds + unit.toNanos(initialDelay);

            Disposable d = schedule(new PeriodicTask(firstStartInNanoseconds, decoratedRun, firstNowNanoseconds, sd,
                    periodInNanoseconds), initialDelay, unit);

            if (d == EmptyDisposable.INSTANCE) {
                return d;
            }
            first.replace(d);

            return sd;
        }

        public long now(@NonNull TimeUnit unit) {
            return unit.convert(System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }

        ...
        
    }

1.1 SingleScheduler

SingleScheduler是RxJava2新增的Scheduler。SingleScheduler中有一个属性叫executor，它是使用AtomicReference包装的ScheduledExecutorService。

final AtomicReference executor = new AtomicReference();

在SingleScheduler构造函数中，executor会调用lazySet()。

    public SingleScheduler(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
        executor.lazySet(createExecutor(threadFactory));
    }

它的createExecutor()用于创建工作线程，可以看到通过SchedulerPoolFactory来创建ScheduledExecutorService。

    static ScheduledExecutorService createExecutor(ThreadFactory threadFactory) {
        return SchedulerPoolFactory.create(threadFactory);
    }

在SchedulerPoolFactory类的create(ThreadFactory factory) 中，使用newScheduledThreadPool线程池定义定时器，最大允许线程数为1。

    public static ScheduledExecutorService create(ThreadFactory factory) {
        final ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, factory);
        if (exec instanceof ScheduledThreadPoolExecutor) {
            ScheduledThreadPoolExecutor e = (ScheduledThreadPoolExecutor) exec;
            POOLS.put(e, exec);
        }
        return exec;
    }

在SingleScheduler中每次使用ScheduledExecutorService，其实是使用executor.get()。所以说，single拥有一个线程单例。

SingleScheduler会创建一个ScheduledWorker，ScheduledWorker使用jdk的ScheduledExecutorService作为executor。

下面是ScheduledWorker的schedule()方法。使用ScheduledExecutorService的submit()或schedule()来执行runnable。

        @NonNull
        @Override
        public Disposable schedule(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
            if (disposed) {
                return EmptyDisposable.INSTANCE;
            }

            Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

            ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, tasks);
            tasks.add(sr);

            try {
                Future f;
                if (delay <= 0L) {
                    f = executor.submit((Callable