RxJava 源碼分析

個人理解，僅供參考！

例子：

 Observable observable = Observable.create(new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {
                        emitter.onNext("1");
                        emitter.onComplete();
                    }
                });
                Observable observable2 = observable.map(new Function<String,Integer>() {
                    @Override
                    public Integer apply(String s) throws Throwable {
                        return Integer.parseInt(s);
                    }
                });
                Observable observable3 = observable2.subscribeOn(Schedulers.io());
                Observable observable4 = observable3.observeOn(AndroidSchedulers.mainThread());
                observable4.subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {

                    }

                    @Override
                    public void onNext(Integer o) {
                        Log.i("tag","onNext :"+o);
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

源碼：

@CheckReturnValue
@NonNull
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> create(@NonNull ObservableOnSubscribe<T> source) {
    Objects.requireNonNull(source, "source is null");
    return RxJavaPlugins.onAssembly(new ObservableCreate<>(source));
}

RxJavaPlugins.onAssembly 是hook方法，先不用管，直接看new ObservableCreate<>(source)

ObservableCreate<T> extends Observable<T> 
說明ObservableCreate是Observable的子類，Observable是抽象類，實現了ObservableSource接口，該接口的方法是

void subscribe(@NonNull Observer<? super T> observer);
Observable 實現了subscribe方法，在此方法中調用了

subscribeActual(observer);
subscribeActual是抽象類，由具體的子類去實現

ObservableCreate對象創建完成之後就返回Observable

查看RxJavaPlugins.onAssembly源碼可知，傳進去的source,再返回回來；

RxJava 中的操作符都是在Observable類中實現的，因此可以繼續調用操作符方法，這與Builder模式有點類似，但返回的Observable並不是原來的那個；

例如上面的例子返回observable之後繼續調用map方法,如下：

Observable observable2 = observable.map(new Function<String,Integer>() {
    @Override
    public Integer apply(String s) throws Throwable {
        return Integer.parseInt(s);
    }
});

查看map源碼：

public final <R> Observable<R> map(@NonNull Function<? super T, ? extends R> mapper) {
    Objects.requireNonNull(mapper, "mapper is null");
    return RxJavaPlugins.onAssembly(new ObservableMap<>(this, mapper));
}

直接看new ObservableMap<>(this, mapper) ，又實例化了一個ObservableMap對象，看其構造方法：

public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
    super(source);
    this.function = function;
}

mapper是我們例子中傳進來的new Function<String,Integer>() { @Override public Integer apply(String s) throws Throwable { return Integer.parseInt(s); } }

this是指observable.map 中的observable，這樣的話ObservableMap對象就持有了observable實例，這個是在create中創建出來的，在RxJava中成爲上游（Upstream），ObservableMap 也是Observable的子類，然後返回一個Observable，這個返回的Observable 是new出來的，說明不與Create方法返回的不一致；

切換線程操作符 subscribeOn 和 observeOn

例如：

Observable observable3 = observable2.subscribeOn(Schedulers.io());
Observable observable4 = observable3.observeOn(AndroidSchedulers.mainThread());

先分析subscribeOn，

You can instruct an Observable to do its work on a particular Scheduler by calling the Observable’s SubscribeOn operator.

翻譯：

通過調用Observable的SubscribeOn操作符，可以指示Observable在特定的調度程序上執行其工作。

執行什麼樣的工作呢?看源碼：

public final Observable<T> subscribeOn(@NonNull Scheduler scheduler) {
    Objects.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<>(this, scheduler));
}

直接看new ObservableSubscribeOn<>(this, scheduler)，scheduler是我們傳進來的參數Schedulers.io()，

追蹤源碼發現 IO = RxJavaPlugins.initIoScheduler(new IOTask());

最後發現就是一個線程池，僅貼出部分代碼：

public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue(), threadFactory);
}

那我們回到這句代碼new ObservableSubscribeOn<>(this, scheduler)

this,指調用該方法的對象也就是例子中的observable2；

ObservableSubscribeOn構造方法：

public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
    super(source);
    this.scheduler = scheduler;
}

ObservableSubscribeOn 也是Observable的實現類，Observable是抽象類，那ObservableSubscribeOn就是具體實現類；

現在我們回到ObservableSubscribeOn 初始化完成之後返回；

在我們的例子中又調用了observeOn操作符：

Observable observable4 = observable3.observeOn(AndroidSchedulers.mainThread());

看下源碼：

public final Observable<T> observeOn(@NonNull Scheduler scheduler) {
    return observeOn(scheduler, false, bufferSize());
}

scheduler是AndroidSchedulers.mainThread()

private static final class MainHolder {
    static final Scheduler DEFAULT
        = new HandlerScheduler(new Handler(Looper.getMainLooper()), true);
}

接着看observeOn:

public final Observable<T> observeOn(@NonNull Scheduler scheduler, boolean delayError, int bufferSize) {
    Objects.requireNonNull(scheduler, "scheduler is null");
    ObjectHelper.verifyPositive(bufferSize, "bufferSize");
    return RxJavaPlugins.onAssembly(new ObservableObserveOn<>(this, scheduler, delayError, bufferSize));
}

還是看new ObservableObserveOn<>(this, scheduler, delayError, bufferSize)，this指例子中的observable3，scheduler是AndroidSchedulers.mainThread()，

public ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize) {
    super(source);
    this.scheduler = scheduler;
    this.delayError = delayError;
    this.bufferSize = bufferSize;
}

保持了observable3的引用，

初始化完成之後返回；

創建完Observable之後會調用subscribe方法進行訂閱，參數是觀察者Observer,例子如下：

observable4.subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {

    }

    @Override
    public void onNext(Integer o) {
        Log.i("tag","onNext :"+o);
    }

    @Override
    public void onError(@NonNull Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});

看observable4的subscribe方法，observable4 是observeOn操作符返回的對象，也就是ObservableObserveOn類型的，看其subscribe方法，其實也就是調用的subscribeActual(),源碼如下：

@Override
protected void subscribeActual(Observer<? super T> observer) {
    if (scheduler instanceof TrampolineScheduler) {
        source.subscribe(observer);
    } else {
        Scheduler.Worker w = scheduler.createWorker();

        source.subscribe(new ObserveOnObserver<>(observer, w, delayError, bufferSize));
    }
}

Scheduler.Worker w = scheduler.createWorker(); 是創建一個工作線程，接着看後面一句：source是誰？在本例子中source是實例化ObservableObserveOn時傳進來的，也就是observable4，在它之前的稱之爲上游，後面的稱之爲下游；

subscribe()參數是ObserveOnObserver的實例，ObserveOnObserver實例持有observer的引用；持有我們自定義的觀察者的另一個觀察者；

observable3是誰？是observable2調用subscribeOn生成的實例，也就是ObservableSubscribeOn對象，那它的subscribeActual()方法如下：

@Override
public void subscribeActual(final Observer<? super T> observer) {
    final SubscribeOnObserver<T> parent = new SubscribeOnObserver<>(observer);

    observer.onSubscribe(parent);

    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}

new SubscribeOnObserver對象，構造函數：

SubscribeOnObserver(Observer<? super T> downstream) {
    this.downstream = downstream;
    this.upstream = new AtomicReference<>();
}

downstream 是它下游的observer,也就是ObserveOnObserver

接着分析observer.onSubscribe(parent);把SubscribeOnObserver傳進ObserveOnObserver的onSubscribe方法中，此方法就不分析了，也是向上回調；

看後面：parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));

void setDisposable(Disposable d) {
    DisposableHelper.setOnce(this, d);
}

說明scheduler.scheduleDirect(new SubscribeTask(parent)) 是Disposable類型的對象，看如何實現的：

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

說明new SubscribeTask(parent) 是一個Runnable,源碼如下：

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

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

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

SubscribeTask是在ObservableSubscribeOn 類中的一個自定義Runnable,那麼run方法中的source對象就是ObservableSubscribeOn的source，它就是構造函數中傳進來的

public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
    super(source);
    this.scheduler = scheduler;
}

現在繼續分析scheduleDirect方法，參數已經知道了，是一個Runnable,

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

createWorker 是Scheduler中的抽象方法，我們要去看它具體的實現，它具體的實現方法在Scheduler.io()創建出來的實例中，

其實就是IoScheduler,它裏面的createWorker方法：

public Worker createWorker() {
    return new EventLoopWorker(pool.get());
}

其實就是創建一個線程池；然後用runnable和worker組裝成一個DisposeTask，然後調用worker的schedule方法執行，怎麼執行的就要看Worker的實現類了，就是Scheduler.io()產生的對象，實現如下：

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

threadWorker 就是線程池中的一個線程，就是在線程池中執行Task,這裏的Task不是上面方法中的tasks,是action，tasks是

DisposableContainer,是把Task放進DisposableContainer中，應該是起到監控的作用，具體沒分析；這個Task就是上面提到的new SubscribeTask(parent)；SubscribeOn操作符就是把傳進來的Observer放到指定的線程池中去執行;這個執行的任務是什麼樣的任務？就是
source.subscribe(parent);
source就是構造ObservableSubscribeOn對象時傳進來的source，也就是上游的observable,parent就是observer;
現在又回到上游的observable的subscribeActual方法，本例中是ObservableMap對象的subscribeActual（），也就是observable2，

@Override
public void subscribeActual(Observer<? super U> t) {
    source.subscribe(new MapObserver<T, U>(t, function));
}

source是create操作符中生成的Observable,new MapObserver<T, U>(t, function) 實例化map操作符對應的Observer,t是下游的observer,function是map操作符中的參數

然後看create操作符中生成的Observable對象中的subscribeActual方法：

ObservableCreate類實現了subscribeActual方法如下：

@Override
protected void subscribeActual(Observer<? super T> observer) {
    CreateEmitter<T> parent = new CreateEmitter<>(observer);
    observer.onSubscribe(parent);

    try {
        source.subscribe(parent);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}

在此方法內部創建了一個CreateEmitter實例，observer是下游observer傳進來的參數，然後調用

observer.onSubscribe(parent);

source.subscribe(parent);

source是什麼？在ObservableCreate類裏面定義如下：

final ObservableOnSubscribe<T> source;

public ObservableCreate(ObservableOnSubscribe<T> source) {
    this.source = source;
}

source是在ObservableCreate構造函數中賦值的，也就是說實例化ObservableCreate時傳進來的ObservableOnSubscribe類型的變量，回到例子中的Observable.create方法的參數：

new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {
        emitter.onNext("1");
        emitter.onComplete();
    }
}

調用source.subscribe(parent); 也就是調用上面的subscribe方法;該方法中調用emitter.onNext("1");

看下其實現：

@Override
public void onNext(T t) {
    if (t == null) {
        onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
        return;
    }
    if (!isDisposed()) {
        observer.onNext(t);
    }
}調用observer.onNext(t);observer是下游的observer,在我們的例子中是MapObserver,看下MapObserver的onNext實現：

public void onNext(T t) {
    if (done) {
        return;
    }

    if (sourceMode != NONE) {
        downstream.onNext(null);
        return;
    }

    U v;

    try {
        v = Objects.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
    } catch (Throwable ex) {
        fail(ex);
        return;
    }
    downstream.onNext(v);
}

對數據t調用mapper.apply(t)，mapper就是傳進來的function,變換後的數據當作參數，調用下游的onNext,在我們例子中下游是SubscribeOnObserver，它的onNext方法僅僅是調用downstream.onNext(t)，在我們的例子中它的下游是ObserveOnObserver

@Override
public void onNext(T t) {
    if (done) {
        return;
    }

    if (sourceMode != QueueDisposable.ASYNC) {
        queue.offer(t);
    }
    schedule();
}

void schedule() {
    if (getAndIncrement() == 0) {
        worker.schedule(this);
    }
}

看到沒有，observerOn 與SubscribeOn的區別是：observerOn在onNext中執行線程池，SubscribeOn是在subscribeActual()中執行線程池，subscribeActual的執行順序是從下向上，onNext是從上到下執行，由於產生數據在最上面，所以subscribeOn只有第一個有效；

RxJava 源碼分析

Kotlin ? !! ?:含義

startActivities(intents)注意點

APKTool 使用

Android studio 編譯NDK--使用cmake

ListView和RecyclerView中item長按後拖拽

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結