抱着陌生的态度再看Rxjava（二）

如果你已经有了Rxjava1的使用基础，你可以看一下这一篇的大体的提纲，了解就可以链接到三，说不定三都不用看。。
如果没有Rxjava1的基础，就 定心点，小脚并并拢，坐正了往下看。

subscribeOn和observeOn

• 初见

  我们之前在尝试Observable或者是Flowable的subscribe方法时候，有没有在意IDE自动帮我们弹出的方法里有subscribeOn这个鬼，于是我又好奇的点开Observable的源码，搜了下observeOn，结果也有。

  看了下注释，比较抽象。按照我们的chinglish直接从方法上来翻译是在什么地方订阅，在什么地方观察。

  按照我们之前的上下游观点，上游的人抛东西下来，下游的人接住。那么很显然下游的人肯定是观察的人，这个毋庸置疑。那么相应的上游的人就是订阅者（实际上订阅者还是太费解，我们把它理解成抛东西的人）

  那么这两个方法现在按照我们的理解就是在哪里抛东西，和在哪里观察。

  OK，我们来看一下这两个方法的传参，都是Scheduler。

  点进去一看。。。。抽象类。。不能直接用了。。。跪了。。

  完。。。。

  • #####再探
    就这么结束了？？开玩笑！！

  还记得在第一篇中，我们不知道什么东西跟Subscriber一起连用的时候我们怎么做来着！没错！！github，源码目录走起。
  
  我们在根目录下发现schedulers目录，打开，看到Schedulers.java文件，点开来一看

public final class Schedulers {
    @NonNull
    static final Scheduler SINGLE;

    @NonNull
    static final Scheduler COMPUTATION;

    @NonNull
    static final Scheduler IO;

    @NonNull
    static final Scheduler TRAMPOLINE;

    @NonNull
    static final Scheduler NEW_THREAD;
    ...
}

给了我们五个静态类，虽然看了一下，它似乎又在类中维护了这五个Scheduler的单例，但是毕竟是protected的不能直接给哥们儿拿来用啊。

然后一不小心，接着往下看的时候发现了，公有的静态方法，并且返回的还是我们正好需要的Scheduler，我去：

//处理io
public static Scheduler io() 
//处理复杂计算
public static Scheduler computation() 
//普通的单独线程
public static Scheduler single() 
//新起一个线程
public static Scheduler newThread()
//在当前线程中，但是会等到当前线程任务执行完毕之后再去执行
public static Scheduler trampoline()

相应的注释，我也差不多备注在方法上。

于是我们对我们的代码做一定的改动，然后打上相应的log

flowable.subscribeOn(Schedulers.single()).observeOn(Schedulers.newThread()).subscribe(subscriber)；
//当前线程名
Thread.currentThread().getName()

如果你不知道这段代码是获得当前线程的名字，那要么出门左转java线程基础，要么ctrl + W。。。。

我们发现答应出来的log并没有什么问题，和我们预料的一样

02-22 01:05:19.346 31814-31814/org.ding.testmulti E/subscriber: onSubscribe   thread   :    main
02-22 01:05:19.355 31814-4422/org.ding.testmulti E/subscriber: onNext    :    s  hello flowable1
02-22 01:05:19.355 31814-4422/org.ding.testmulti E/subscriber: onNext   thread   :    RxNewThreadScheduler-1
02-22 01:05:19.355 31814-4422/org.ding.testmulti E/subscriber: onNext    :    s  hello flowable2
02-22 01:05:19.355 31814-4422/org.ding.testmulti E/subscriber: onNext   thread   :    RxNewThreadScheduler-1
02-22 01:05:19.355 31814-4423/org.ding.testmulti E/flowable: thread   :    RxSingleScheduler-1

subscriber就是我们所说的下游的观察者，由于我们这里使用到的是flowable和subscriber这一对鸳鸯。需要在onSubscribe方法中去调用Subscription的request方法，就很显然的可以理解，在onSubscribe方法中实际上我们还没有开始建立真正的连接，直到request之后我们在onNext，onError，onComplete中才是真正在observerOn的线程中运行的，可以看到两个onNext都是newThread没错。
subscribeOn就是上游的线程，定义在flowable的subscribe中的方法就是运行在我们定义的singleThread没错。

• #####细思
  
  • ######主线程怎么没有
    主线程是我们使用最最频繁的线程了，所有的UI操作都要放在我们的主线程中去进行，那设想一下，如果我们需要在上游或者是下游做一些UI操作，当然如果我们没有刻意的去使用SubscribeOn和ObserverOn，而我们的subscribe方法又正好在主线程中调用，那没有问题，整个都是在主线程中跑的，要是我们使用了呢，怎么办呢，Schedulers里面并没有提供主线程这个东西啊，没有main这个东西啊

我又去找github了，目录翻了一圈，也没有找到MainThread这个鬼，好了，这回真放弃，大家再见。。。。

醒了醒神，再回过头想想，主线程这个东西，是否是安卓特地适配的呢，rxjava中怎么可能会出现android特有的东西呢。。。

• ######为我们的rxjava添上Android的模块
  说时迟，那时快。。。。（好老）
  我们立马前往ReativeX的github库，看到RxGo，RxKotlin（java8来了你颤抖么），再往下，找到了RxAndroid！！
  点进去，看目录！！
  
  你没有看错，rxandroid里面只有这些。。。
  还正好出现了我们需要的AndroidSchedulers，赶紧吃饱辣条，点击去看看

/** A {@link Scheduler} which executes actions on the Android main thread. */
    public static Scheduler mainThread() {
        return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
}

还要我说废话么。。。
去module setting里面搜搜看这个dependency，注意哦，rxandroid也有适配rxjava1和rxjava2的两种版本哦，我们使用的是rxjava2的版本

compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

• 上下游的On关系

  不知道细心的你有没有去尝试过一个问题，只用subscribeOn和只用observerOn会出现什么情况。
  通过打印日志，你会发现

  如果只定义了上游的线程，而没有定义下游的线程，那么下游的线程将跟随上游的线程；
  如果只定义了下游的线程，那么上游的线程将依然使用当前线程。
  

  实际上也很好理解，上游发生了海啸洪水必然会影响下游，导致下游也波澜。而下游起了波澜，上游该咋地还咋地。

  • Schedulers的几个方法具体区别
    我们在上面大体的把几个都解释了一下，但是具体的什么时候用什么呢，我们一一来看
    
    • compute
      还记的上面说的维护了静态五个Scheduler么，我们看到compute对应的Scheduler是ComputationScheduler，源码走起！

/**
* Create a scheduler with pool size equal to the available processor
* count and using least-recent worker selection policy.
*/
public ComputationScheduler() {
    this(THREAD_FACTORY);
}

注释够明显了么，翻译过来大致是说会起一个线程池，大小跟available processor的数量（就是CPU数量）相等，并使用最近的工作线程选择策略。
也就是说，compute方法会用把方法放在一个大小等于CPU核数的线程池中执行。
* single

public SingleScheduler() {
      this(SINGLE_THREAD_FACTORY);
}
public SingleScheduler(ThreadFactory threadFactory) {
      this.threadFactory = threadFactory;
      executor.lazySet(createExecutor(threadFactory));
}
static ScheduledExecutorService createExecutor(ThreadFactory threadFactory) {
      return SchedulerPoolFactory.create(threadFactory);
}

我们看到也是创建了一个线程池，我们去create方法继续看，

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;
}
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
          super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue(), threadFactory);
}

不知道在android面试实用版2中，大家有否记得，说道的几个线程池，这里用到到就是计划线程池，主要是用来在未来的某一时刻进行执行的线程池，我们看到传入的是1，也就是说single会让方法在核心线程为1的线程池中工作。

 * io

public IoScheduler() {
        this(WORKER_THREAD_FACTORY);
}
public IoScheduler(ThreadFactory threadFactory) {
        this.threadFactory = threadFactory;
        this.pool = new AtomicReference<CachedWorkerPool>(NONE);
        start();
}

使用的一个叫CachedWorkerPool的内部类，

CachedWorkerPool(long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory) {
        this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0L;
        this.expiringWorkerQueue = new ConcurrentLinkedQueue<ThreadWorker>();
        this.allWorkers = new CompositeDisposable();
        this.threadFactory = threadFactory;

        ScheduledExecutorService evictor = null;
        Future<?> task = null;
        if (unit != null) {
            evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
            task = evictor.scheduleWithFixedDelay(this, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS);
        }
        evictorService = evictor;
        evictorTask = task;
}

ScheduledThreadPoo线程池，每一个任务相隔60纳秒（好小的样子）。并且维护了一个任务队列

ThreadWorker get() {
        if (allWorkers.isDisposed()) {
            return SHUTDOWN_THREAD_WORKER;
        }
        while (!expiringWorkerQueue.isEmpty()) {
            ThreadWorker threadWorker = expiringWorkerQueue.poll();
            if (threadWorker != null) {
                return threadWorker;
            }
        }

        // No cached worker found, so create a new one.
        ThreadWorker w = new ThreadWorker(threadFactory);
        allWorkers.add(w);
        return w;
}

可以不断的对任务队列进行处理，可以认为这个队列是无限长的，好了。。这边扯得有点远。。
也就是说io会让方法执行在一个无数量上线的线程池

• newThread
  newThreadScheduler的代码是最少的，我们直接可以看到

@NonNull
@Override
public Worker createWorker() {
    return new NewThreadWorker(threadFactory);
}

每次都会起一个新的线程，也就是说newthread会让方法都在新的线程中执行
* trampoline
如注释。就是在当前线程中执行，并且等当前线程执行完了之后再去执行。
别问我怎么没有源码了，因为我不懂。

那么综上所述，一般我们使用的最多的应该就是主线程和io了，如果你要使用其他的方法，那么具体任务具体分析了。