RxJava(四)：线程操作

博客主页

1. 调度器（Scheduler）的种类

1.1 RxJava 线程介绍

RxJava 是一个为异步编程而实现的库，异步是其重要特色，合理地利用异步编程能够提高系统的处理速度。但是异步也会带来线程的安全问题，而且异步并不等于并发，与异步概念相对应的是同步。

在默认情况下， RxJava 只在当前线程中运行，它是单线程的。此时 Observable 用于发射数据流，Observer 用于接收和响应数据流，各种操作符（ Operators ）用于加工数据流，它们都在同一个线程中运行，实现出来的是一个同步的函数响应式。然而，函数响应式的实际应用是大部分操作都在后台处理，前台响应的一个过程。所以需要对刚才的流程做一下修改，改成 Observable 生成发射数据流， Operators 加工数据流在后台线程中进行， Observer 在前台线程中接收井响应数据。此时会涉及使用多线程来操作 RxJava ，我们可以使用 RxJava 的调度器（Scheduler）来实现。

1.2 Scheduler

Scheduler 是 RxJava 对线程控制器的一个抽象， RxJava 内置了多个 Scheduler 的实现，它们基本满足绝大多数使用场景。

如果内置的 Scheduler 不能满足业务需求，那么可以使用自定义的 Executor 作为调度器，以满足个性化需求。

Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter emitter) throws Exception {
        Log.d(TAG, "subscribe: " + Thread.currentThread().getName());
        emitter.onNext("hello");
        emitter.onNext("world");
    }
}).observeOn(Schedulers.newThread())
        .subscribe(new Consumer() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, Thread.currentThread().getName() + "#Next: " + s);
            }
        });

// 执行结果
 subscribe: main
 RxNewThreadScheduler-1#Next: hello
 RxNewThreadScheduler-1#Next: world

这里的 Observable 发射完数据之后，切换到 newThread 。后面的两次打印都是在 newThread 中进行的。

2. RxJava 线程模型

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

Observable.just("aaa", "bbb")
        .observeOn(Schedulers.newThread())
        .map(new Function() {
            @Override
            public String apply(String s) throws Exception {
                Log.d(TAG, "apply: " + Thread.currentThread().getName());
                return s.toUpperCase();
            }
        }).subscribeOn(Schedulers.single())
        .observeOn(Schedulers.io())
        .subscribe(new Consumer() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, Thread.currentThread().getName() + "#Next: " + s);
            }
        });

// 执行结果
 apply: RxNewThreadScheduler-1
 apply: RxNewThreadScheduler-1
 RxCachedThreadScheduler-1#Next: AAA
 RxCachedThreadScheduler-1#Next: BBB

其中，蓝色表示主线程、橙色表示 newThread 、粉色表示 I/O 线程

2.1 线程调度器

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

2.1.1 computation()

computation() 用于 CPU 密集型的计算任务，但井不适合 I/O 操作

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

2.1.2 io()

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

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

2.1.3 trampoline()

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

public static Scheduler trampoline() {
    return TRAMPOLINE;
}

2.1.4 newThread()

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

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

2.1.5 single()

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

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

2.1.6 自定义的 Executor 来作为调度器

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

2.2 Scheduler源码

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

// Scheduler.java

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 {
   
    @NonNull
    public Disposable schedule(@NonNull Runnable run) {
        return schedule(run, 0L, TimeUnit.NANOSECONDS);
    }

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

    @NonNull
    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;
    }
}

2.2.1 SingleScheduler

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

// SingleScheduler.java

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);
    tryPutIntoPool(PURGE_ENABLED, exec);
    return exec;
}

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

SingleScheduler 会创建一个 ScheduledWorker, ScheduledWorker 使用 JDK 的ScheduledExecutorService 作为 executor

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

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