RXAndroid2.0初学习二

28

public void onSubscribe(Disposable s) {

    if (DisposableHelper.validate(this.s, s)) {

        this.s = s;        if (s instanceof QueueDisposable) {

            @SuppressWarnings("unchecked")

            QueueDisposable<T> qd = (QueueDisposable<T>) s;            int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY);            if (m == QueueDisposable.SYNC) {

                sourceMode = m;                queue = qd;                done = true;                actual.onSubscribe(this);                schedule();                return;            }

            if (m == QueueDisposable.ASYNC) {

                sourceMode = m;                queue = qd;                actual.onSubscribe(this);                return;            }

        }

 

        queue = new SpscLinkedArrayQueue<T>(bufferSize);        actual.onSubscribe(this);    }

}

 

继续，执行actual.onSubscribe(this),actual=DisposableObserver,this就不多说了。

 

29

继续贴出代码：

 

final AtomicReference<Disposable> s = new AtomicReference<Disposable>();@Overridepublic final void onSubscribe(@NonNull Disposable s) {

    if (EndConsumerHelper.setOnce(this.s, s, getClass())) {

        onStart();    }

}

 

AtomicReference是一个原子引用，这是Java库中的。不了解的可以自己百度一下。

 

30

if (EndConsumerHelper.setOnce(this.s, s, getClass())) {

        onStart();    }

public static boolean setOnce(AtomicReference<Disposable> upstream, Disposable next, Class<?> observer) {

    ObjectHelper.requireNonNull(next, "next is null");    if (!upstream.compareAndSet(null, next)) {

        next.dispose();        if (upstream.get() != DisposableHelper.DISPOSED) {

            reportDoubleSubscription(observer);        }

        return false;    }

    return true;}

简单描述一下上述方法中的参数吧，第一个是AtomicReference原子引用，第二个也是ObservableObserveon.ObserveOnObserver，第三个是DisposableObserver这个class，

上面会直接返回true，然后执行onstart（）函数，是一个空方法，

 

此时会重新回到代码27，然后执行下面代码：

 

31

ObservableSubscribeOn中的代码：

public void subscribeActual(final Observer<? super T> s) {

    final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);    s.onSubscribe(parent);    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));}

 

执行parent.setDisposable(scheduler.scheduleDirect(new SubscibeTask(parent))),其中scheduler=IoScheduler,是在代码10中返回的，目前一共有两个schedule，一个是

IoSchedule,一个是HandlerSchedule，大家心里有谱就好了。上面代码中大家是不是感觉见到光了，Task出现了，说明线程要调用了。

 

说明：

SubscribeTask:extends Runnable,

其中

32

scheduler.scheduleDirect(new SubscribeTask(parent))

执行到内部，大家又感觉很高兴了，

33

public Disposable scheduleDirect(@NonNull Runnable run) {

    return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);}

 

34

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

 

decoratedRun其实就是上面的run,DisposeTask implements Runnable, Disposable，

w.schedule代码执行：

35

public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {

    if (tasks.isDisposed()) {

        // don't schedule, we are unsubscribed        return EmptyDisposable.INSTANCE;    }

 

    return threadWorker.scheduleActual(action, delayTime, unit, tasks);}

 

执行

36

IOSchedule.EvenLoopworker中执行，

threadWorker.scheduleActual(action, delayTime, unit, tasks);

 

我们说一下threadWorker，这个是ThreadWorker，他不是一个线程对象，但是他是一个包装有线程的对象，他含有ScheduledExecutorService对象，可以将runnable放到线程

中执行。

 

37

继续贴出代码：

这个是在ThreadWorker中的父类中NewThreadWorker中执行的。

public ScheduledRunnable scheduleActual(Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {

    Runnable decoratedRun = RxJavaPlugins.onSchedule(run);    ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);    if(parent != null && !parent.add(sr)) {

        return sr;    } else {

        try {

            Object f;            if(delayTime <= 0L) {

                f = this.executor.submit(sr);            } else {

                f = this.executor.schedule(sr, delayTime, unit);            }

 

            sr.setFuture((Future)f);        } catch (RejectedExecutionException var10) {

            if(parent != null) {

                parent.remove(sr);            }

 

            RxJavaPlugins.onError(var10);        }

 

        return sr;    }

}

 

其中executor就是线程调度执行器ScheduledExecutorService对象，就是在线程中执行

    ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);

 

执行了submit后，就会调用ScheduleRunnable中的run方法，

 

38

public void run() {
    lazySet(THREAD_INDEX, Thread.currentThread());
    try {
        try {
            actual.run();
        } catch (Throwable e) {
            // Exceptions.throwIfFatal(e); nowhere to go
            RxJavaPlugins.onError(e);
        }
    } finally {
        lazySet(THREAD_INDEX, null);
        Object o = get(PARENT_INDEX);
        if (o != DISPOSED && o != null && compareAndSet(PARENT_INDEX, o, DONE)) {
            ((DisposableContainer)o).delete(this);
        }

        for (;;) {
            o = get(FUTURE_INDEX);
            if (o == DISPOSED || compareAndSet(FUTURE_INDEX, o, DONE)) {
                break;
            }
        }
    }
}

 其中actual是Schedule.DisposeTask，贴代码：

39

public void run() {
    runner = Thread.currentThread();
    try {
        decoratedRun.run();
    } finally {
        dispose();
        runner = null;
    }
}

其中decoratedRun

40

执行如下代码：

final class SubscribeTask implements Runnable {
    private final SubscribeOnObserver<T> parent;

    SubscribeTask(SubscribeOnObserver<T> parent) {
        this.parent = parent;
    }

    @Override
    public void run() {
        source.subscribe(parent);
    }
}

 其中source=ObservableDef，

41

ObServable中的代码，

public final void subscribe(Observer<? super T> observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer);

        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");

        subscribeActual(observer);
    } catch (NullPointerException e) { // NOPMD
        throw e;
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // can't call onError because no way to know if a Disposable has been set or not
        // can't call onSubscribe because the call might have set a Subscription already
        RxJavaPlugins.onError(e);

        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
        npe.initCause(e);
        throw npe;
    }
}

42

subscribeActual（observer）方法调用，在ObservableDef中进行执行，

public void subscribeActual(Observer<? super T> s) {
    ObservableSource<? extends T> pub;
    try {
        pub = ObjectHelper.requireNonNull(supplier.call(), "null ObservableSource supplied");
    } catch (Throwable t) {
        Exceptions.throwIfFatal(t);
        EmptyDisposable.error(t, s);
        return;
    }

    pub.subscribe(s);
}

到这里已经开始要执行call（）方法，supplier=observer，这个是sample代码中的sampleObservable方法中的回调，

43

static Observable<String> sampleObservable() {
    return Observable.defer(new Callable<ObservableSource<? extends String>>() {
      @Override public ObservableSource<? extends String> call() throws Exception {
            // Do some long running operation
            SystemClock.sleep(5000);
            return Observable.just("one", "two", "three", "four", "five");
        }
    });
}

执行Obsevable.just()方法，此时基本上已经达成了demo中的第一步，在子线程中运行（43），回调到主线程（后面会）。

44

这段代码上面有贴过：

new DisposableObserver<String>() {
    @Override public void onComplete() {
        Log.d(TAG, "onComplete()");
    }

    @Override public void onError(Throwable e) {
        Log.e(TAG, "onError()", e);
    }

    @Override public void onNext(String string) {
        Log.d(TAG, "onNext(" + string + ")");
    }
})

上面44已经跑题，后面怎么调用主线程的工作，下一篇稳重在进行说明。