两个奶头被吃得又翘又硬,波多野结衣一区二区三区高清,精品人人搡人妻人人玩a片

1、關于線程調度的例子, 就只用過幾個操作符, 所以只針對這幾個操作符進行源碼閱讀;
2、關于線程調度, 有下面幾個api需要分析:

Schedulers.newThread();
AndroidSchedulers.mainThread()
Schedulers.io();

3、關于newThread與io, 是如何操作線程池?
4、demo1講Schedulers.newThread(), demo2講Schedulers.io()
5、切記一句話, 一旦看暈了, 趕緊翻到最后結合流程圖嘗試對當前片段的理解;

demo1 :

Observable
        .create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                LogUtils.log(Note01.class, "subscribe()->ThreadName:" + Thread.currentThread().getName());
                emitter.onNext(1);
                emitter.onComplete();
            }
        })
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                LogUtils.log(Note01.class, "onSubscribe()->ThreadName:" + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Integer value) {
                LogUtils.log(Note01.class, "onNext()->ThreadName:" + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                LogUtils.log(Note01.class, "onError()->ThreadName:" + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                LogUtils.log(Note01.class, "onComplete()->ThreadName:" + Thread.currentThread().getName());
            }
        });

打印結果:

04-24 21:05:57.418 3141-3141/ Note01->onSubscribe()->ThreadName:main
04-24 21:05:57.418 3141-3241/ Note01->subscribe()->ThreadName:RxNewThreadScheduler-1
04-24 21:05:57.418 3141-3141/ Note01->onNext()->ThreadName:main
04-24 21:05:57.418 3141-3141/ Note01->onComplete()->ThreadName:main

一、Schedulers.newThread:

1.1 Schedulers.newThread

public final class Schedulers {
    static final Scheduler NEW_THREAD;

    static {
        NEW_THREAD = RxJavaPlugins.initNewThreadScheduler(new Callable<Scheduler>() {
            @Override
            public Scheduler call() throws Exception {
                return NewThreadHolder.DEFAULT;
            }
        });
    }

    public static Scheduler newThread() {
        return NEW_THREAD;
    }

    static final class NewThreadHolder {
        static final Scheduler DEFAULT = NewThreadScheduler.instance();
    }
}
public final class NewThreadScheduler extends Scheduler {

    public static NewThreadScheduler instance() {
        return INSTANCE;
    }

    private static final NewThreadScheduler INSTANCE = new NewThreadScheduler();
}

主要是構建Schedules的實例, 實際指向NewThreadScheduler, 給這里的Schedulers打算標簽,Schedulers_1(NewThreadScheduler);

1.2 Observable.subscribeOn:

public abstract class Observable<T> implements ObservableSource<T> {
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable<T> subscribeOn(Scheduler scheduler) {
        return new ObservableSubscribeOn<T>(this, scheduler);
    }
}

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Scheduler scheduler;
    /** 
     * 1. ObservableSubscribeOn持有Observable_1(ObservableCreate)的引用, 
     *    ObservableSubscribeOn持有Scheduler_1(NewThreadScheduler)的引用, 繼續模塊<1.4>;
     * 2. 給此處返回的ObservableSubscribeOn打上標簽Observable_2(ObservableSubscribeOn);
     */
    public ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler) {
        super(source);
        this.scheduler = scheduler;
    }
}

1.3 AndroidSchedulers.mainThread:

public final class AndroidSchedulers {

    private static final class MainHolder {

        static final Scheduler DEFAULT = new HandlerScheduler(new Handler(Looper.getMainLooper()));
    }

    private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
            new Callable<Scheduler>() {
                @Override public Scheduler call() throws Exception {
                    return MainHolder.DEFAULT;
                }
            });

    public static Scheduler mainThread() {
        return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
    }
}

創建一個持有主線程Handler的HandlerScheduler實例, 給此處的HandlerScheduler打上標簽, Schedulers_2(HandlerScheduler);

1.4 Observable.observeOn:

public abstract class Observable<T> implements ObservableSource<T> {
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable<T> observeOn(Scheduler scheduler) {
        return observeOn(scheduler, false, bufferSize());
    }
    @SchedulerSupport(SchedulerSupport.CUSTOM)
    public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
        /**
         * 1. 給此處構造的實例ObservableObserveOn打上標簽為Observable_3(ObservableObserveOn),
         * 而這里的this指向的是Observable_2(ObservableSubscribeOn);
         * 2. 同時Observable_3(ObservableObserveOn)持有Schedulers_2(HandlerScheduler)的引用;
         */
        return new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize);
    }
}

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

1.1 ~ 1.4僅僅是進行了初始化實例的操作, 很關鍵的一點是每次調用都會返回一個Observable對象, 該Observable對象會持有前一個Observable的引用, 這點也是RxJava鏈式調用的一個核心;

1.5 Observable.subscribe:

結合RxJava系列_01ObservableEmitter可知, Observable.subscribe實際會觸發最后一個Observable的subscribeActual方法;

1.6 Observable3(ObservableObserveOn).subscribe:

public final class ObservableObserveOn<T> extends AbstractObservableWithUpstream<T, T> {
    final Observer<? super T> actual;
    protected final ObservableSource<T> source;
    /**
     * Observable3(ObservableObserveOn).subscribe最終會觸發subscribeActual的執行;
     */
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        Scheduler.Worker w = scheduler.createWorker();
        /**
         * 1. 然后傳入Observer的實例, 此處給Observer打上標簽Observer_1(Observer);
         * 2. 然后將Observer_1(Observer)與w(HandlerScheduler)封裝進ObserveOnObserver,
         *    給此處的ObserveOnObserver打上標簽Observer_2(ObserveOnObserver);
         * 3. 然后通過subscribe將Observer_2(ObserveOnObserver)傳給Observable2(ObservableObserveOn);
         */
        source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
    }
}

final class HandlerScheduler extends Scheduler {
    private final Handler handler;

    HandlerScheduler(Handler handler) {
        this.handler = handler;
    }
    @Override
    public Worker createWorker() {
        return new HandlerWorker(handler);
    }
}

1.7 Observable_2(ObservableSubscribeOn).subscribeActual:

public final class ObservableSubscribeOn<T> extends AbstractObservableWithUpstream<T, T> {
    @Override
    public void subscribeActual(final Observer<? super T> s) {
        /**
         * 1. 給此處的parent打上標簽Observer_3(SubscribeOnObserver);
         * 2. Observer_3(SubscribeOnObserver)持有Observer_2(ObserveOnObserver)的引用;
         * 3. Observer_2(ObserveOnObserver)通過onSubscribe持有
         *    Observer_3(SubscribeOnObserver)的引用, 又是一個相互持有的過程;
         */
        final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
        
        /**
         * Observer_2(ObserveOnObserver)通過onSubscribe持有
         * Observer_3(SubscribeOnObserver)的引用, 又是一個相互持有的過程進入到模塊<1.8>;
         */
        s.onSubscribe(parent);
        /**
         * 1. 此處的schedule實際為Scheduler_1(NewThreadScheduler), 進入模塊<1.9>中;
         */
        scheduler.scheduleDirect(new Runnable() {
            @Override
            public void run() {
                /**
                 * 1. 通過對模塊<1.9>的分析可知, source.subscribe(parent)運行在子線程中;
                 * 2. 此處的source指向Observable_1(ObservableCreate), 通過subscribe, 
                 *    Observable_1(ObservableCreate)持有parent即Observer_3(SubscribeOnObserver)
                 *    的引用, 然后進入模塊<1.10>;
                 */
                source.subscribe(parent);
            }
        });
    }

    static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {

        final Observer<? super T> actual;

        final AtomicReference<Disposable> s;

        SubscribeOnObserver(Observer<? super T> actual) {
            this.actual = actual;
            this.s = new AtomicReference<Disposable>();
        }
}

1.8 Observer_2(ObserverOnObserver).onSubscribe:

static final class ObserverOnObserver<T> implements Observer<T>, Runnable {

    final Observer<? super T> actual;
    final Scheduler.Worker worker;
    Disposable s;
    /**
     * 1. 此處的ObserverOnObserver為Observer_2(ObserverOnObserver), 在模塊<1.6>中被創建;
     * 2. 有模塊<1.6>可知, 此處的actual指向Observer_1(Observer);
     * 3. 而worker指向了Worker(HandlerScheduler);
     */
    ObserverOnObserver(Observer<? super T> actual, Scheduler.Worker worker, boolean delayError, int bufferSize) { 
        this.actual = actual;
        this.worker = worker;
    }

    @Override
    public void onSubscribe(Disposable s) {
        /**
         * 類似于遞歸的方式, 依次往上調用, 直到調用到Observer1.onSubscribe為止;
         * 到目前為止還沒有發現有子線程的跡象, 所以此時Observer.onSubscribe(Dispose)運行在主線程;
         */
        actual.onSubscribe(this);
    }
}

1.9 NewThreadScheduler.scheduleDirect:

public abstract class NewThreadScheduler {
    public Disposable scheduleDirect(Runnable run, long delay, TimeUnit unit) {
        final Worker w = createWorker();

        final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

        w.schedule(new Runnable() {
            @Override
            public void run() {
                try {
                    decoratedRun.run();
                } finally {
                    w.dispose();
                }
            }
        }, delay, unit);

        return w;
    }

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

public class NewThreadWorker extends Scheduler.Worker implements Disposable {
    private final ScheduledExecutorService executor;

    volatile boolean disposed;

    public NewThreadWorker(ThreadFactory threadFactory) {
        executor = SchedulerPoolFactory.create(threadFactory);
    }
}

創建線程池, 使run運行在子線程中;

1.10 Observable_1(ObservableCreate).subscribe:

public final class ObservableCreate<T> extends Observable<T> {
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        /**
         * 1. 此處的observer實際為Observer_3(SubscribeOnObserver);
         * 2. source實際為ObservableOnSubscribe, 通過subscribe持有CreateEmitter的引用;
         */ 
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);
        source.subscribe(parent);
    }
}

目前算是完成了觀察者觀察事件的注冊, 接下來被觀察者通過CreateEmitter發送幾個事件看看會發生些什么;

1.11 CreateEmitter.onNext:

static final class CreateEmitter<T> extends AtomicReference<Disposable>  implements ObservableEmitter<T>, Disposable {

    final Observer<? super T> observer;

    CreateEmitter(Observer<? super T> observer) {
        this.observer = observer;
    }

    @Override
    public void onNext(T t) {
        if (!isDisposed()) {
            /**
             * 為Observer_3(SubscribeOnObserver)觸發onNext的執行, 進入到模塊<1.12>;
             */
            observer.onNext(t);
        }
    }
}

1.12 Observer_3(SubscribeOnObserver).onNext:

static final class SubscribeOnObserver<T> extends AtomicReference<Disposable> implements Observer<T>, Disposable {

    final Observer<? super T> actual;

    final AtomicReference<Disposable> s;

    @Override
     public void onNext(T t) {
        /**
         * Observer_3(SubscribeOnObserver)在模塊<1.7>進行初始化, 然后傳入Observer_2(ObserveOnObserver)
         * 使actual指向Observer_2(ObserveOnObserver);
         */
        actual.onNext(t);
    }
}

1.13 Observer_2(ObserveOnObserver).onNext:

static final class ObserveOnObserver<T> extends BasicIntQueueDisposable<T> implements Observer<T>, Runnable {
    @Override
    public void onNext(T t) {
        if (done) {
            return;
        }
        schedule();
    }

    void schedule() {
        if (getAndIncrement() == 0) {
           /**
            * Observer_2(ObserveOnObserver)在模塊<1.6>處被初始化, 并且傳入HandlerWorker使worker
            * 指向worker, 然后觸發Observer_2(ObserveOnObserver)的run方法的執行;
            */
            worker.schedule(this);
        }
    }
    /**
     * 通過閱讀HandlerWorker源碼可知, HandlerWorker通過schedule將run運行在主線程中;
     */
    @Override
    public void run() {
        if (outputFused) {
            drainFused();
        } else {
            drainNormal();
        }
    }
    void drainNormal() {
        /**
         * actual指向的是Observer_1(Observer);
         */
        actual.onNext(v);
    }
}

關于demo1的流程圖:

關于demo1的流程圖

1、關于上面的流程大致可以看清楚RxJava的套路了, 首先是Observable<N>持有Observable<N-1>的引用, 然后在Observable<N>的subscribe中傳入Observer1, 并創建Observer2, Observer2持有Observer1的引用, 然后將Observer2傳給Observable<N-1>, 采用遞歸的方式, 直到Observable<1>持有Observer<N>的引用為止, 此時將Observer<N>傳給CreateEmitter, 然后當執行CreateEmitter.onNext事件時, Observer.onNext的方式為Observer<N> ---> Observer<1>;
2、在1的總結中也可以看出來, Observable與Observer的索引為逆序持有;

demo2:

Observable
        .create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                LogUtils.log(Note01.class, "subscribe()->ThreadName:" + Thread.currentThread().getName());
                emitter.onNext(1);
                emitter.onComplete();
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {
                LogUtils.log(Note01.class, "onSubscribe()->ThreadName:" + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Object value) {
                LogUtils.log(Note01.class, "onNext()->ThreadName:" + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                LogUtils.log(Note01.class, "onError()->ThreadName:" + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                LogUtils.log(Note01.class, "onComplete()->ThreadName:" + Thread.currentThread().getName());
            }
       });

關于demo2, 只分析Scheduler.io, 其他的在demo1里面已經進行了分析, demo1Schedulers.newThread每次都會創建一個新的線程池;

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

RxJava系列_02線程調度

RxJava系列_02線程調度

demo1 :

一、Schedulers.newThread:

1.1 Schedulers.newThread

1.2 Observable.subscribeOn:

1.3 AndroidSchedulers.mainThread:

1.4 Observable.observeOn:

1.5 Observable.subscribe:

1.6 Observable3(ObservableObserveOn).subscribe:

1.7 Observable_2(ObservableSubscribeOn).subscribeActual:

1.8 Observer_2(ObserverOnObserver).onSubscribe:

1.9 NewThreadScheduler.scheduleDirect:

1.10 Observable_1(ObservableCreate).subscribe:

1.11 CreateEmitter.onNext:

1.12 Observer_3(SubscribeOnObserver).onNext:

1.13 Observer_2(ObserveOnObserver).onNext:

關于demo1的流程圖:

demo2:

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

RxJava系列_02線程調度

demo1 :

一、Schedulers.newThread:

1.1 Schedulers.newThread

1.2 Observable.subscribeOn:

1.3 AndroidSchedulers.mainThread:

1.4 Observable.observeOn:

1.5 Observable.subscribe:

1.6 Observable3(ObservableObserveOn).subscribe:

1.7 Observable_2(ObservableSubscribeOn).subscribeActual:

1.8 Observer_2(ObserverOnObserver).onSubscribe:

1.9 NewThreadScheduler.scheduleDirect:

1.10 Observable_1(ObservableCreate).subscribe:

1.11 CreateEmitter.onNext:

1.12 Observer_3(SubscribeOnObserver).onNext:

1.13 Observer_2(ObserveOnObserver).onNext:

關于demo1的流程圖:

demo2:

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频