rxjava源码分析

RXjava响应式编程

此文作者大暴雨原创，转载请注明出处。

如果线程的知识不是很丰富，请先查看     rxjava源码中的线程知识  一文

rxjava总结就是：异步
实现主要是通过扩展观察者模式

首先我们看一下只有一条线程是怎么实现响应式的。这比较简单。首先看一下Observable这个类（被观察者），还有Subscriber （观察者），Subscriber实现了Observer 类。

Observable从create开始

public static <T> Observable<T> create(OnSubscribe<T> f) {
        return new Observable<T>(hook.onCreate(f));
    }
    create方法就是new一个Observable对象，参数是hook.onCreate(f)。hook是RxJavaObservableExecutionHook类，RxJavaObservableExecutionHook这个类什么也没有做就是传进去什么参数，返回什么。所以这里的hook.onCreate(f)，返回的就是f对象，就是OnSubscribe。
    
    
    再看一下Observable的构造方法，参数是OnSubscribe获取

protected Observable(OnSubscribe<T> f) {
        this.onSubscribe = f;
    }
    Observable的构造方法就是为了获取订阅对象

看一下观察者和被观察者是怎么联系的。执行订阅的方法就会执行subscribe.call方法.
   private static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
        
        ...
        ...
        
        subscriber.onStart();
        
        ...
        
        try {
            // allow the hook to intercept and/or decorate
            hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
            return hook.onSubscribeReturn(subscriber);
        } catch (Throwable e) {
           ...
        }
    }

首先调用subscriber.onStart();这个onstart要自己重写，因为这个onStart方法，默认是空的，什么也没有做。最后调用hook.onSubscribeStart(observable,observable.onSubscribe).call(subscriber);hook.onSubscribeStart这返回的observable.onSubscribe这个参数，之前已经说过，hook是什么也没有干的，你传什么参数进去就返回什么。实际上就是observable.onSubscribe的call方法。onSubscribe这个接口继承自Action1，action1的call方法然后再拆分为不同的接口，例如onNext()，onCompleted()，onError()。这样就实现了从创建到触发call回调了。接下来看一下多线程，响应式是怎么实现的。毕竟异步才是响应式的核心。

响应式多线程的实现

1.调用的方式

指定事件在哪个线程执行：subscribeOn(Scheduler scheduler)
    指定事件的响应在哪个线程：observeOn(Scheduler scheduler)

首先看参数是Scheduler调度器。调度器的类型Schedulers这个类。
    
    
    public final class Schedulers {

private final Scheduler computationScheduler;
        private final Scheduler ioScheduler;
        private final Scheduler newThreadScheduler;

private static final Schedulers INSTANCE = new Schedulers();

private Schedulers() {
            Scheduler c = RxJavaPlugins.getInstance().getSchedulersHook().getComputationScheduler();
            if (c != null) {
                computationScheduler = c;
            } else {
                computationScheduler = new EventLoopsScheduler();
            }

Scheduler io = RxJavaPlugins.getInstance().getSchedulersHook().getIOScheduler();
            if (io != null) {
                ioScheduler = io;
            } else {
                ioScheduler = new CachedThreadScheduler();
            }

Scheduler nt = RxJavaPlugins.getInstance().getSchedulersHook().getNewThreadScheduler();
            if (nt != null) {
                newThreadScheduler = nt;
            } else {
                newThreadScheduler = NewThreadScheduler.instance();
            }
        }
        
        省略一些get类，和测试类
        ...
        ...
    
    }
    
    这里可以看到rxjava提供三种线程，android有多一些。Schedulers是一个单列的。RxJavaPlugins.getInstance().getSchedulersHook()这个类和hook是一样的，传什么就返回什么，不传就返回null。所以这里一定是跑else的代码。

接下来已io为例，看一下初始化Scheduler。CachedThreadScheduler继承Scheduler。

final class CachedThreadScheduler extends Scheduler implements SchedulerLifecycle {
    
    private static final String WORKER_THREAD_NAME_PREFIX = "RxCachedThreadScheduler-";
    
    一些初始化的操作，略
    ...
    
    
    //缓存线程的操作
    private static final class CachedWorkerPool {
        private final long keepAliveTime;
        private final ConcurrentLinkedQueue<ThreadWorker> expiringWorkerQueue;
        private final CompositeSubscription allWorkers;//保存正在使用的subscriptions
        private final ScheduledExecutorService evictorService;
        
        private final Future<?> evictorTask;

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

ScheduledExecutorService evictor = null;
            Future<?> task = null;
            if (unit != null) {
                evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
                NewThreadWorker.tryEnableCancelPolicy(evictor);
                task = evictor.scheduleWithFixedDelay(
                        new Runnable() {
                            @Override
                            public void run() {
                                evictExpiredWorkers();
                            }
                        }, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS
                );
            }
            evictorService = evictor;
            evictorTask = task;
        }

ThreadWorker get() {
            
            if (allWorkers.isUnsubscribed()) {
                return SHUTDOWN_THREADWORKER;
            }
            //从队列去找
            while (!expiringWorkerQueue.isEmpty()) {
                ThreadWorker threadWorker = expiringWorkerQueue.poll();
                if (threadWorker != null) {
                    return threadWorker;
                }
            }

// No cached worker found, so create a new one.
            //没有worker，就new一个
            ThreadWorker w = new ThreadWorker(WORKER_THREAD_FACTORY);
            
            //添加到缓存allWorkers中
            allWorkers.add(w);
            return w;
        }

void release(ThreadWorker threadWorker) {
            // Refresh expire time before putting worker back in pool
            threadWorker.setExpirationTime(now() + keepAliveTime);
            //插入队列尾部
            expiringWorkerQueue.offer(threadWorker);
        }
        //移除当前除了当前外的ThreadWorker。
        void evictExpiredWorkers() {
            if (!expiringWorkerQueue.isEmpty()) {
                long currentTimestamp = now();

for (ThreadWorker threadWorker : expiringWorkerQueue) {
                    if (threadWorker.getExpirationTime() <= currentTimestamp) {
                        if (expiringWorkerQueue.remove(threadWorker)) {
                            allWorkers.remove(threadWorker);
                        }
                    } else {
                        // Queue is ordered with the worker that will expire first in the beginning, so when we
                        // find a non-expired worker we can stop evicting.
                        break;
                    }
                }
            }
        }

...
    }

final AtomicReference<CachedWorkerPool> pool;
    
    static final CachedWorkerPool NONE;
    static {
        NONE = new CachedWorkerPool(0, null);
        NONE.shutdown();
    }
    
    public CachedThreadScheduler() {
        this.pool = new AtomicReference<CachedWorkerPool>(NONE);
        start();
    }
    
    ...
    ...
    
    @Override
    public Worker createWorker() {
        return new EventLoopWorker(pool.get());
    }

//线程操作的类
    private static final class EventLoopWorker extends Scheduler.Worker {
        private final CompositeSubscription innerSubscription = new CompositeSubscription();//保存正在使用的subscriptions
        private final CachedWorkerPool pool;//缓存线程
        private final ThreadWorker threadWorker；
        @SuppressWarnings("unused")
        volatile int once;
        static final AtomicIntegerFieldUpdater<EventLoopWorker> ONCE_UPDATER
                = AtomicIntegerFieldUpdater.newUpdater(EventLoopWorker.class, "once");

EventLoopWorker(CachedWorkerPool pool) {
            this.pool = pool;
            this.threadWorker = pool.get();//获取工作线程
        }

@Override
        public void unsubscribe() {
            if (ONCE_UPDATER.compareAndSet(this, 0, 1)) {
                // unsubscribe should be idempotent, so only do this once
                pool.release(threadWorker);//插入线程
            }
            innerSubscription.unsubscribe();
        }

@Override
        public boolean isUnsubscribed() {
            return innerSubscription.isUnsubscribed();
        }

@Override
        public Subscription schedule(Action0 action) {
            return schedule(action, 0, null);
        }

@Override
        public Subscription schedule(Action0 action, long delayTime, TimeUnit unit) {
            if (innerSubscription.isUnsubscribed()) {
                // don't schedule, we are unsubscribed
                return Subscriptions.unsubscribed();
            }
            //这个是真正执行任务的线程
            ScheduledAction s = threadWorker.scheduleActual(action, delayTime, unit);//执行线程，把action关联起来
            
            innerSubscription.add(s);
            s.addParent(innerSubscription);
            
            
            return s;
        }
    }

private static final class ThreadWorker extends NewThreadWorker {
        private long expirationTime;

ThreadWorker(ThreadFactory threadFactory) {
            super(threadFactory);
            this.expirationTime = 0L;
        }
        
        public long getExpirationTime() {
            return expirationTime;
        }

public void setExpirationTime(long expirationTime) {
            this.expirationTime = expirationTime;
        }
    }
}
    
    
    这里有两个内部类，CachedWorkerPool和EventLoopWorker这两个类。CachedWorkerPool是缓存线程，把ThreadWorker放到队列里面，提供一些操作的方法，例如get方法获取ThreadWorker对象，还有一些插入，清除等操作。EventLoopWorker线程的操作类，首先从缓存线程中取出一个ThreadWorker，在schedule方法中实现了threadWorker.scheduleActual这个方法，这个方法就是真正执行任务的线程。接着简要看一下threadWorker.scheduleActual这个方法。
    
    threadWorker类的scheduleActual方法：
    
     public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit) {
        Action0 decoratedAction = schedulersHook.onSchedule(action);
        ScheduledAction run = new ScheduledAction(decoratedAction);
        Future<?> f;
        if (delayTime <= 0) {
            f = executor.submit(run);
        } else {
            f = executor.schedule(run, delayTime, unit);
        }
        run.add(f);

return run;
    }
    
    ScheduledAction的run方法：
    public void run() {
        try {
            lazySet(Thread.currentThread());
            action.call();
        } catch (Throwable e) {
            // nothing to do but print a System error as this is fatal and there is nowhere else to throw this
            IllegalStateException ie = null;
            if (e instanceof OnErrorNotImplementedException) {
                ie = new IllegalStateException("Exception thrown on Scheduler.Worker thread. Add `onError` handling.", e);
            } else {
                ie = new IllegalStateException("Fatal Exception thrown on Scheduler.Worker thread.", e);
            }
            RxJavaPlugins.getInstance().getErrorHandler().handleError(ie);
            Thread thread = Thread.currentThread();
            thread.getUncaughtExceptionHandler().uncaughtException(thread, ie);
        } finally {
            unsubscribe();
        }
    }
    
    cheduledAction这个类是执行的线程,这个类就是把action和线程绑定，在线程中调用action.call()方法。这里启动executor线程池，执行任务，run.add(f)线程执行结果添加到cheduledAction中。这样子就能在一个线程中执行call方法。
    
    这里是以io为例，所有都是继承Scheduler类的，所以看一下Scheduler这个类。

public abstract class Scheduler {

static final long CLOCK_DRIFT_TOLERANCE_NANOS;
    static {
        CLOCK_DRIFT_TOLERANCE_NANOS = TimeUnit.MINUTES.toNanos(
                Long.getLong("rx.scheduler.drift-tolerance", 15));
    }
    
   
    public abstract Worker createWorker();

public abstract static class Worker implements Subscription {

public abstract Subscription schedule(Action0 action);

public abstract Subscription schedule(final Action0 action, final long delayTime, final TimeUnit unit);

public Subscription schedulePeriodically(final Action0 action, long initialDelay, long period, TimeUnit unit) {
            final long periodInNanos = unit.toNanos(period);
            final long firstNowNanos = TimeUnit.MILLISECONDS.toNanos(now());
            final long firstStartInNanos = firstNowNanos + unit.toNanos(initialDelay);

final MultipleAssignmentSubscription mas = new MultipleAssignmentSubscription();
            final Action0 recursiveAction = new Action0() {
                long count;
                long lastNowNanos = firstNowNanos;
                long startInNanos = firstStartInNanos;
                @Override
                public void call() {
                    if (!mas.isUnsubscribed()) {
                        action.call();
                        
                        long nextTick;
                        
                        long nowNanos = TimeUnit.MILLISECONDS.toNanos(now());
                        
                        if (nowNanos + CLOCK_DRIFT_TOLERANCE_NANOS < lastNowNanos
                                || nowNanos >= lastNowNanos + periodInNanos + CLOCK_DRIFT_TOLERANCE_NANOS) {
                            nextTick = nowNanos + periodInNanos;
                            
                            startInNanos = nextTick - (periodInNanos * (++count));
                        } else {
                            nextTick = startInNanos + (++count * periodInNanos);
                        }
                        lastNowNanos = nowNanos;
                        
                        long delay = nextTick - nowNanos;
                        mas.set(schedule(this, delay, TimeUnit.NANOSECONDS));
                    }
                }
            };
            MultipleAssignmentSubscription s = new MultipleAssignmentSubscription();
            // Should call `mas.set` before `schedule`, or the new Subscription may replace the old one.
            mas.set(s);
            s.set(schedule(recursiveAction, initialDelay, unit));
            return mas;
        }

public long now() {
            return System.currentTimeMillis();
        }
    }

public long now() {
        return System.currentTimeMillis();
    }
    
    在父类可以看到，createWorker，创建一个EventLoopWorker,然后就是调用Worker的schedulePeriodically方法也会调用schedule方法，去执行任务。上面已经说了，schedule方法就是通过从缓存队列中获取ThreadWorker，然后执行scheduleActual方法。去实现在线程中执行任务。我们已经理解了参数Scheduler，这个时候看看怎么用这个调度器类。
    
    指定事件在哪个线程执行：subscribeOn(Scheduler scheduler)
    
    public final Observable<T> observeOn(Scheduler scheduler) {
        if (this instanceof ScalarSynchronousObservable) {
            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
        }
        return lift(new OperatorObserveOn<T>(scheduler, false));
    }
    
    首先看一下ScalarSynchronousObservable.scalarScheduleOn方法
    
     public Observable<T> scalarScheduleOn(final Scheduler scheduler) {
        final Func1<Action0, Subscription> onSchedule;
        if (scheduler instanceof EventLoopsScheduler) {
            final EventLoopsScheduler els = (EventLoopsScheduler) scheduler;
            onSchedule = new Func1<Action0, Subscription>() {
                @Override
                public Subscription call(Action0 a) {
                    return els.scheduleDirect(a);
                }
            };
        } else {
            onSchedule = new Func1<Action0, Subscription>() {
                @Override
                public Subscription call(final Action0 a) {
                    final Scheduler.Worker w = scheduler.createWorker();
                    w.schedule(new Action0() {
                        @Override
                        public void call() {
                            try {
                                a.call();
                            } finally {
                                w.unsubscribe();
                            }
                        }
                    });
                    return w;
                }
            };
        }
        
        return create(new ScalarAsyncOnSubscribe<T>(t, onSchedule));
    }
    
    可以看到，如果是EventLoopsScheduler，就直接创建Func1，如果不是，我们举例io就不是EventLoopsScheduler，是CachedThreadScheduler，就是跑else代码，scheduler.createWorker()，创建一个Worker，然后执行schedule，schedule方法已经说了，就是指定线程执行。在线程的call方法中执行onSchedule.call()回调。
    
    
    源码分析到此处。如果哪里有错误，请指出谢谢。
    
    
    此文作者大暴雨原创，转载请注明出处。