• RXJava源码分析

    一、RxJava链式调用流程分析

    1.本质是观察者模式和装饰器模式的运用

    1.         Observable.create(new ObservableOnSubscribe() {
    2.             @Override
    3.             public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {
    4.  
    5.             }
    6.         }).map(new Function() {
    7.                     @Override
    8.                     public Integer apply(String s) throws Throwable {
    9.                         return null;
    10.                     }
    11.                 }).subscribe(new Observer() {
    12.             @Override
    13.             public void onSubscribe(@NonNull Disposable d) {
    14.  
    15.             }
    16.  
    17.             @Override
    18.             public void onNext(@NonNull Integer character) {
    19.  
    20.             }
    21.  
    22.             @Override
    23.             public void onError(@NonNull Throwable e) {
    24.  
    25.             }
    26.  
    27.             @Override
    28.             public void onComplete() {
    29.  
    30.             }
    31.         });

     流程分析：

     

     对于被观察者来说，装饰器模式体现在subscribeActual方法

    对于观察者来说，装饰器模式体现在onNext方法

    2.源码分析一个最简单的链式调用流程，同时要体会到观察者模式作用

    1.         Observable.create(new ObservableOnSubscribe() {
    2.             @Override
    3.             public void subscribe(@NonNull ObservableEmitter emitter) throws Throwable {
    4.                 emitter.onNext("A");
    5.                 emitter.onComplete();
    6.             }
    7.         }).subscribe(new Observer() {
    8.             @Override
    9.             public void onSubscribe(@NonNull Disposable d) {
    10.  
    11.             }
    12.  
    13.             @Override
    14.             public void onNext(@NonNull String s) {
    15.                 System.out.println(s);
    16.             }
    17.  
    18.             @Override
    19.             public void onError(@NonNull Throwable e) {
    20.  
    21.             }
    22.  
    23.             @Override
    24.             public void onComplete() {
    25.                 
    26.             }
    27.         });

    这段代码，主要就是三块儿，第一块儿是被观察者Observable，第二块是观察者Observer，第三块是订阅观察者和被观察者。

    我们要通过源码把订阅的细节和如何使用emiter发射到observer的。

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

    首先这个Observable.create()方法的返回值还是Observable，参数是ObservableOnSubscribe

    1. public interface ObservableOnSubscribe<@NonNull T> {
    2.  
    3.     /**
    4.      * Called for each {@link Observer} that subscribes.
    5.      * @param emitter the safe emitter instance, never {@code null}
    6.      * @throws Throwable on error
    7.      */
    8.     void subscribe(@NonNull ObservableEmitter emitter) throws Throwable;
    9. }
    return RxJavaPlugins.onAssembly(new ObservableCreate<>(source));

    首先看RxJavaPlugins.onAssembly()什么作用:

    1.     public static <@NonNull T> Observable onAssembly(@NonNull Observable source) {
    2.         Functionsuper Observable, ? extends Observable> f = onObservableAssembly;
    3.         if (f != null) {
    4.             return apply(f, source);
    5.         }
    6.         return source;
    7.     }

    这个其实是一个预留的可以插入的hook节点，默认情况下这个onObservableAssembly是null，所以直接返回的是new ObservableCreate<>(source)，只有在设置了:

    1.         RxJavaPlugins.setOnObservableAssembly(new Function() {
    2.             @Override
    3.             public Observable apply(Observable observable) throws Throwable {
    4.                 System.out.println("监控日志");
    5.                 return observable;
    6.             }
    7.         });
    8.  
    9.     public static void setOnObservableAssembly(@Nullable Functionsuper Observable, ? extends Observable> onObservableAssembly) {
    10.         if (lockdown) {
    11.             throw new IllegalStateException("Plugins can't be changed anymore");
    12.         }
    13.         RxJavaPlugins.onObservableAssembly = onObservableAssembly;
    14.     }

    设置了setOnObservableAssembly之后onObservableAssembly就不为null了，这时每次执行Observable.create()方法，都会调用apply方法，这样就可以在apply方法中添加一些监控的日志等，所以说这是一个预留的hook节点，只有设置之后才会有效，如果不设置相当于直接返回new ObservableCreate<>(source),所以Observable.create()方法最后的返回值是ObservableCreate是一个被观察者Observable。

    Observable.create()的参数ObservableOnSubscribe，作为ObservableCreate<>(source)的参数，维护在了被观察者ObservableCreate中。

    然后我们看，具体如何订阅的:

    首先订阅操作是Observable.subscribe(observer)，所以我们看Observable的subscribe方法:

    1.     public final void subscribe(@NonNull Observersuper T> observer) {
    2.         Objects.requireNonNull(observer, "observer is null");
    3.         try {
    4.             observer = RxJavaPlugins.onSubscribe(this, observer);
    5.  
    6.             Objects.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");
    7.  
    8.             subscribeActual(observer);
    9.         } catch (NullPointerException e) { // NOPMD
    10.             throw e;
    11.         } catch (Throwable e) {
    12.             Exceptions.throwIfFatal(e);
    13.             // can't call onError because no way to know if a Disposable has been set or not
    14.             // can't call onSubscribe because the call might have set a Subscription already
    15.             RxJavaPlugins.onError(e);
    16.  
    17.             NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
    18.             npe.initCause(e);
    19.             throw npe;
    20.         }
    21.     }

    可以看到subscribe方法主要就是调用了subscribeActual方法，可是subscribeActual是一个抽象方法，我们知道这一定是在子类中有具体的实现，我们知道Observable的实现类是ObservableCreate，所以我们看ObservableCreate的subscribeActual方法:

    1.     protected void subscribeActual(Observersuper T> observer) {
    2.         CreateEmitter parent = new CreateEmitter<>(observer);
    3.         observer.onSubscribe(parent);
    4.  
    5.         try {
    6.             source.subscribe(parent);
    7.         } catch (Throwable ex) {
    8.             Exceptions.throwIfFatal(ex);
    9.             parent.onError(ex);
    10.         }
    11.     }

    首先创建了CreateEmitter，并且把观察者observer当作参数维护在CreateEmitter中，然后调用观察者observer的onSubscribe方法，这就是为啥observer的onSubscribe方法最先执行，因为一执行subscribe订阅方法，就会调用到observer的onSubscribe方法。

    订阅重点到了:

    source.subscribe(parent);

     source就是Observable.create()的参数ObservableOnSubscribe，parent是CreateEmitter，CreateEmitter持有observer，通过source.subscribe(parent);之后ObservableOnSubscribe持有了CreateEmitter，这个source.subscribe方法的作用是回调，这也是事件发射最起始的地方。

    观察者模式可以理解成被观察者持有观察者的引用，那总结一下上面的引用的持有链，观察者observer被CreateEmitter持有，CreateEmitter被ObservableOnSubscribe持有 ，ObservableOnSubscribe被被观察者ObservableCreate持有，并以回调的方式使用CreateEmitter，所以当我们在Observable.create()的参数ObservableOnSubscribe中，可以操作CreateEmitter来发送事件，最终到oberver。

    3.分析map方法源码，同时体会装饰器模式

    1.     public final <@NonNull R> Observable map(@NonNull Functionsuper T, ? extends R> mapper) {
    2.         Objects.requireNonNull(mapper, "mapper is null");
    3.         return RxJavaPlugins.onAssembly(new ObservableMap<>(this, mapper));
    4.     }
    5.  
    6. public final class ObservableMap extends AbstractObservableWithUpstream 
    7. {
    8.  
    9.     final Functionsuper T, ? extends U> function;
    10.  
    11.     public ObservableMap(ObservableSource source, Functionsuper T, ? extends U> function) {
    12.         super(source);
    13.         this.function = function;
    14.     }
    15.  
    16.     public void subscribeActual(Observersuper U> t) {
    17.         source.subscribe(new MapObserver(t, function));
    18.     }
    19.  
    20.  
    21.  
    22. }

    首先source是在map方法中的this，这个this就是上一个Observable，可以看到ObservableMap是用source持有了上一个Observable，且在subscribeActual方法中调用了source.subscribe(new MapObserver(t, function));方法，这个MapObserver持有下一个Observer，而这个Observer会在MapObserver中的onNext方法中调用自己的onNext方法。

    所以我们总结出:

    对于被观察者来说，装饰器模式体现在subscribeActual方法

    对于观察者来说，装饰器模式体现在onNext方法

    装饰器模式对于观察者链的作用，首先观察者和被观察者的关系是一一对应的，终点的观察者被最近的被观察者订阅，并且在被观察者的装饰器方法subscribeActual中，会创建一个新的Observer，让上一个被观察者和新创建的观察者订阅，新创建的观察者持有终点观察者，这样就能把整个观察链打通。

    二、Disposable的dispose方法的执行过程

     dispose方法：

    1.         public void dispose() {
    2.             DisposableHelper.dispose(this);
    3.         }

    DisposableHelper 的 dispose() 方法的定义如下。按照上面的分析，dispose() 的时候传入的 this 就是 CreateEmitter. 并且它是继承了 AtomicReference 的。

    1.     public static boolean dispose(AtomicReference field) {
    2.         Disposable current = field.get();
    3.         Disposable d = DISPOSED;
    4.         if (current != d) {
    5.             current = field.getAndSet(d);
    6.             if (current != d) {
    7.                 if (current != null) {
    8.                     current.dispose();
    9.                 }
    10.                 return true;
    11.             }
    12.         }
    13.         return false;
    14.     }

    对 AtomicReference，相比大家都不陌生，它是一个原子类型的引用。这里正式通过对该原子类型引用的赋值来完成取消订阅的——通过一个原子操作将其设置为 DISPOSED.

     这个DisposableHelper是什么：

    1. public enum DisposableHelper implements Disposable {
    2.     /**
    3.      * The singleton instance representing a terminal, disposed state, don't leak it.
    4.      */
    5.     DISPOSED
    6.     ;

    它是一个枚举类型，只有一个值是DISPOSED，同时它也实现了Disposable接口。

    看一个DisposableHelper的方法：

    1.     public static boolean isDisposed(Disposable d) {
    2.         return d == DISPOSED;
    3.     }
    4.  
    5.         public void onNext(T t) {
    6.             if (t == null) {
    7.                 onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
    8.                 return;
    9.             }
    10.             if (!isDisposed()) {
    11.                 observer.onNext(t);
    12.             }
    13.         }

    从这就可以看出来，当把Disposable赋值为DISPOSED时，就说明上下游已经断开了，不让发送了

    三、线程切换的本质

     1.subscribeOn(Schedulers.io())

     (1).Schedulers.io()起到什么作用

    1.     public static Scheduler io() {
    2.         return RxJavaPlugins.onIoScheduler(IO);
    3.     }
    4.     
    5.     //🌟这个IO就是一个Scheduler
    6.     static final Scheduler IO;
    7.  
    8.     IO = RxJavaPlugins.initIoScheduler(new IOTask());
    9.  
    10.     static final class IOTask implements Supplier {
    11.         @Override
    12.         public Scheduler get() {
    13.             return IoHolder.DEFAULT;
    14.         }
    15.     }
    16.  
    17.     static final class IoHolder {
    18.         static final Scheduler DEFAULT = new IoScheduler();
    19.     }

    从这个调用链下来，我们知道了，这个Schedulers.io()是一个Scheduler，它的实现类是一个IoScheduler

    调用了Schedulers.io()会创建IoScheduler对象，肯定会执行IoScheduler的构造方法，我们看一下这个IoScheduler的构造方法

    1.     public IoScheduler() {
    2.         this(WORKER_THREAD_FACTORY);
    3.     }
    4.  
    5.     public IoScheduler(ThreadFactory threadFactory) {
    6.         this.threadFactory = threadFactory;
    7.         this.pool = new AtomicReference<>(NONE);
    8.         start();
    9.     }
    10.  
    11.     public void start() {
    12.         CachedWorkerPool update = new CachedWorkerPool(KEEP_ALIVE_TIME, KEEP_ALIVE_UNIT, threadFactory);
    13.         if (!pool.compareAndSet(NONE, update)) {
    14.             update.shutdown();
    15.         }
    16.     }

    我们看到通过this.pool可以获取到CachedWorkerPool，重点是这个CachedWorkerPool是啥？

    1.     static final class CachedWorkerPool implements Runnable {
    2.  
    3.         private final ScheduledExecutorService evictorService;
    4.         private final Future evictorTask;
    5.  
    6.         CachedWorkerPool(long keepAliveTime, TimeUnit unit, ThreadFactory threadFactory) {
    7.             this.keepAliveTime = unit != null ? unit.toNanos(keepAliveTime) : 0L;
    8.             this.expiringWorkerQueue = new ConcurrentLinkedQueue<>();
    9.             this.allWorkers = new CompositeDisposable();
    10.             this.threadFactory = threadFactory;
    11.  
    12.             ScheduledExecutorService evictor = null;
    13.             Future task = null;
    14.             if (unit != null) {
    15.                 evictor = Executors.newScheduledThreadPool(1, EVICTOR_THREAD_FACTORY);
    16.                 task = evictor.scheduleWithFixedDelay(this, this.keepAliveTime, this.keepAliveTime, TimeUnit.NANOSECONDS);
    17.             }
    18.             evictorService = evictor;
    19.             evictorTask = task;
    20.         }
    21.  
    22.  
    23.     }

    可以看出CachedWorkerPool实现了Runnable接口，同时它内部维护了线程池。

    我们可以总结了Schedulers.io()创建了一个IoScheduler对象，这个对象内部维护了一个线程池。

    (2).subscribeOn()的作用是什么

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

    和其他的map等方法一样，subscribeOn()也是创建一个实现类为ObservableSubscribeOn的Observable，这个ObservableSubscribeOn中持有链式调用中的上一个Observable，同时在装饰器的主要方法subscribeActual内部实现链式订阅，new了一个实现类为new SubscribeOnObserver<>(observer)的Observer，然后把上一个Observable和这个SubscribeOnObserver订阅，我们总结是链式调用的观察者模式中，总是上一个被观察者Observable订阅下一个Observer观察者，因为链式调用中开头一定是先有被观察者Observable。

    这个SubscribeOnObserver持有下一个Observer的引用，这也是装饰器模式的运用，装饰器的主要作用方法是onNext，通过onNext方法不断的调用持有的下一个observer的onNext来达到链式调用的效果，其实订阅的本质就是要被观察者Observable持有观察者Observer，又因为链式调用开始一定是被观察者，所以一定是上一个被观察者被下一个观察者订阅，而notify下发的本质就是被观察者发出notify动作，然后通过onNext方法通知它的观察者，观察者的onNext方法中先执行参数方法，参数方法就是例如Map的参数方法就是转换函数new Function()，然后再通知下一个观察者observer，直到终点observer。

     我们已知Observable的订阅方法是subscribeActual，下面我们继续看这个ObservableSubscribeOn的subscribeActual方法干了什么：

    1.     final Scheduler scheduler;
    2.  
    3.     public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) {
    4.         super(source);
    5.         this.scheduler = scheduler;
    6.     }
    7.  
    8.     @Override
    9.     public void subscribeActual(final Observersuper T> observer) {
    10.         final SubscribeOnObserver parent = new SubscribeOnObserver<>(observer);
    11.  
    12.         observer.onSubscribe(parent);
    13.  
    14.         parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
    15.     }

    首先这个scheduler就是IoScheduler，主要就是这一句

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

    中的

    scheduler.scheduleDirect(new SubscribeTask(parent))

    先看 new SubscribeTask(parent)):

    1.     final class SubscribeTask implements Runnable {
    2.         private final SubscribeOnObserver parent;
    3.  
    4.         SubscribeTask(SubscribeOnObserver parent) {
    5.             this.parent = parent;
    6.         }
    7.  
    8.         @Override
    9.         public void run() {
    10.             source.subscribe(parent);
    11.         }
    12.     }

    很简单是一个Runnable，run方法中的source就是上一个Observable，和SubscribeOnObserver进行了订阅，这意味着如果这个Runnable在其他线程中执行，则从执行这个run方法开始，后面所有的代码包括被观察者调用观察者的observer的onNext方法并且传递到终点的观察者的onNext方法都会执行在这个线程中。

    首先我们知道订阅是一个从下往上的过程，线程的转换是发生在订阅时，所以如果是：

    1.         ObservableA
    2.                 .subscribeOn(Schedulers.A())
    3.         ObervableB
    4.                 .subscribeOn(Schedulers.B())
    5.         ObervableC
    6.                 .subscribeOn(Schedulers.C())

    那它最终会执行在线程A中，这也是我们常说的第一个subscribeOn的线程有效。

    那如何把这个Runnable对象交给线程执行的呢？

    那就要看我们的scheduler.scheduleDirect方法：

    1.     public Disposable scheduleDirect(@NonNull Runnable run) {
    2.         return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
    3.     }
    4.  
    5.     public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
    6.         final Worker w = createWorker();
    7.  
    8.         final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
    9.  
    10.         DisposeTask task = new DisposeTask(decoratedRun, w);
    11.  
    12.         w.schedule(task, delay, unit);
    13.  
    14.         return task;
    15.     }

    我们已经知道scheduler的实现类是IoScheduler，我们一句一句分析scheduleDirect方法

    final Worker w = createWorker();

    对应 IoScheduler中的:

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

    我们已经知道pool.get()就是获取到能操作线程池的CachedWorkerPool类，而这个EventLoopWorker是用来管理操作线程池的类:

    1.     static final class EventLoopWorker extends Scheduler.Worker implements Runnable {
    2.         private final CompositeDisposable tasks;
    3.         private final CachedWorkerPool pool;
    4.         private final ThreadWorker threadWorker;
    5.  
    6.         final AtomicBoolean once = new AtomicBoolean();
    7.  
    8.         EventLoopWorker(CachedWorkerPool pool) {
    9.             this.pool = pool;
    10.             this.tasks = new CompositeDisposable();
    11.             this.threadWorker = pool.get();
    12.         }
    13.  
    14.         @Override
    15.         public void dispose() {
    16.             if (once.compareAndSet(false, true)) {
    17.                 tasks.dispose();
    18.  
    19.                 if (USE_SCHEDULED_RELEASE) {
    20.                     threadWorker.scheduleActual(this, 0, TimeUnit.NANOSECONDS, null);
    21.                 } else {
    22.                     // releasing the pool should be the last action
    23.                     pool.release(threadWorker);
    24.                 }
    25.             }
    26.         }
    27.  
    28.         @Override
    29.         public void run() {
    30.             pool.release(threadWorker);
    31.         }
    32.  
    33.         @Override
    34.         public boolean isDisposed() {
    35.             return once.get();
    36.         }
    37.  
    38.         @NonNull
    39.         @Override
    40.         public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
    41.             if (tasks.isDisposed()) {
    42.                 // don't schedule, we are unsubscribed
    43.                 return EmptyDisposable.INSTANCE;
    44.             }
    45.  
    46.             return threadWorker.scheduleActual(action, delayTime, unit, tasks);
    47.         }
    48.     }

    我们看第二句： 

    final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);

    run是SubscribeTask也就是我们线程切换的runnable，RxJavaPlugins.onSchedule就是RxJava常用的Hook预留，它和RxJavaPlugins.onAssembly作用一样，就是给外部一个能插入执行此代码的预留，默认还是返回原Runnable。

    DisposeTask task = new DisposeTask(decoratedRun, w);
......
return task;

    把runnable包装成实现Disposable和Runnable接口的包装类，让他既能中断又能给线程执行，看最后会把task返回，其实主要是为了能中断。

    看第三句:

    w.schedule(task, delay, unit);

    这句对应IoScheduler中的EventLoopWorker的schedule方法:

    1.       public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
    2.             if (tasks.isDisposed()) {
    3.                 // don't schedule, we are unsubscribed
    4.                 return EmptyDisposable.INSTANCE;
    5.             }
    6.  
    7.             return threadWorker.scheduleActual(action, delayTime, unit, tasks);
    8.         }
    9.  
    10.  
    11.     public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
    12.         Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
    13.  
    14.         ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
    15.  
    16.         if (parent != null) {
    17.             if (!parent.add(sr)) {
    18.                 return sr;
    19.             }
    20.         }
    21.  
    22.         Future f;
    23.         try {
    24.             if (delayTime <= 0) {
    25.                 f = executor.submit((Callable)sr);
    26.             } else {
    27.                 f = executor.schedule((Callable)sr, delayTime, unit);
    28.             }
    29.             sr.setFuture(f);
    30.         } catch (RejectedExecutionException ex) {
    31.             if (parent != null) {
    32.                 parent.remove(sr);
    33.             }
    34.             RxJavaPlugins.onError(ex);
    35.         }
    36.  
    37.         return sr;
    38.     }
      39.  

       可以看到它实际上就是把runnable转换成Callable之后交给线程池执行了。
       

      对线程池不熟的可以看我这篇文章:Java 多线程，并发编程_AllenC6的博客-CSDN博客_java多线程并发编程一、创建线程有几种方式看了好多博文，都说三种或者三种之上的，其实本质只有两种，有Java源码Thread类的上面的注释为证:There are two ways to create a new thread of execution. One is to declare a class to be a subclass of Thread....The other way to create a thread is to declare a class that implements thehttps://blog.csdn.net/m0_37707561/article/details/125065803
       

       到这里我们知道了subscribeOn(Schedulers.io())切换线程就是把订阅操作放到了runnable中，并且交给了线程池执行。
       

      2.observeOn(AndroidSchedulers.mainThread())
       

      (1). AndroidSchedulers.mainThread()的作用
       

      1.     public static Scheduler mainThread() {
      2.         return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
      3.     }
      4.  
      5.     private static final Scheduler MAIN_THREAD =
      6.         RxAndroidPlugins.initMainThreadScheduler(() -> MainHolder.DEFAULT);
      7.  
      8.     private static final class MainHolder {
      9.         static final Scheduler DEFAULT
      10.             = new HandlerScheduler(new Handler(Looper.getMainLooper()), true);
      11.     }
       

      通过调用链，我们可以知道AndroidSchedulers.mainThread()，最后创建了一个和IoScheduler类似的HandlerScheduler，并且HandlerScheduler持有mainThread的Handler，这下我们应该能想到，肯定是要把任务交给Handler去执行，这样就能实现执行在主线程中,具体细节下面分析。
       

      (2).observeOn()的作用
       

      1.     public final Observable observeOn(@NonNull Scheduler scheduler) {
      2.         return observeOn(scheduler, false, bufferSize());
      3.     }
      4.  
      5.     public final Observable observeOn(@NonNull Scheduler scheduler, boolean delayError, int bufferSize) {
      6.         Objects.requireNonNull(scheduler, "scheduler is null");
      7.         ObjectHelper.verifyPositive(bufferSize, "bufferSize");
      8.         return RxJavaPlugins.onAssembly(new ObservableObserveOn<>(this, scheduler, delayError, bufferSize));
      9.     }
       

      主要就是这个ObservableObserveOn，它其实就是一个Observable，Observable订阅的时候会执行subscribeActual方法，所以我们重点看这个方法:
       

      1.     protected void subscribeActual(Observersuper T> observer) {
      2. ......
      3.             Scheduler.Worker w = scheduler.createWorker();
      4.  
      5.             source.subscribe(new ObserveOnObserver<>(observer, w, delayError, bufferSize));
      6.         }
      7.     }
       

      这个scheduler很明显是HandlerScheduler，scheduler.createWorker的代码:
       

      1.     public Worker createWorker() {
      2.         return new HandlerWorker(handler, async);
      3.     }
       

      source是上一个Observable，要订阅新创建的Observer即ObserveOnObserver,ObserveOnObserver的装饰器主要方法是onNext，下面我们主要看ObserveOnObserver的onNext方法:
       

      1.     public void onNext(T t) {
      2.         if (done) {
      3.             return;
      4.         }
      5.         if (sourceMode != QueueDisposable.ASYNC) {
      6.             queue.offer(t);
      7.         }
      8.         schedule();
      9.     }
      10.  
      11.     void schedule() {
      12.         if (getAndIncrement() == 0) {
      13.             worker.schedule(this);
      14.         }
      15.     }
       

      这个worker是HandlerWorker，这个this就是本身实现了Runnable接口，这个runnable之后会交给handler去执行，真正执行的就是ObserveOnObserver的run方法，我们结下来看HandlerWorker的schedule方法:
       

      1.         public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
      2.             if (run == null) throw new NullPointerException("run == null");
      3.             if (unit == null) throw new NullPointerException("unit == null");
      4.  
      5.             if (disposed) {
      6.                 return Disposable.disposed();
      7.             }
      8.  
      9.             run = RxJavaPlugins.onSchedule(run);
      10.  
      11.             ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
      12.  
      13.             Message message = Message.obtain(handler, scheduled);
      14.             message.obj = this; // Used as token for batch disposal of this worker's runnables.
      15.  
      16.             if (async) {
      17.                 message.setAsynchronous(true);
      18.             }
      19.  
      20.             handler.sendMessageDelayed(message, unit.toMillis(delay));
      21.  
      22.             // Re-check disposed state for removing in case we were racing a call to dispose().
      23.             if (disposed) {
      24.                 handler.removeCallbacks(scheduled);
      25.                 return Disposable.disposed();
      26.             }
      27.  
      28.             return scheduled;
      29.         }
       

      主要是这几句:
       

      ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);

Message message = Message.obtain(handler, scheduled);
message.obj = this; // Used as token for batch disposal of this worker's runnables.

if (async) {
    message.setAsynchronous(true);
}

handler.sendMessageDelayed(message, unit.toMillis(delay));
       

      从这里可以看出来，就是把任务交给了主线程的Handler去执行，达到的让任务执行在主线程的效果，当主线程执行时会执行ObserveOnObserver的run方法:
       

      1.         @Override
      2.         public void run() {
      3.             if (outputFused) {
      4.                 drainFused();
      5.             } else {
      6.                 drainNormal();
      7.             }
      8.         }
      9.  
      10.         void drainFused() {
      11. ......
      12.  
      13.                 downstream.onNext(null);
      14.  
      15. ......
      16.         }
      17.  
      18.         void drainNormal() {
      19. ......
      20.             final Observersuper T> a = downstream;
      21.  
      22. ......
      23.  
      24.                     a.onNext(v);
      25.                 }
      26.  
      27. ......
      28.         }
       

      不难看出，主线程的handler执行的代码，就是调用下游的observer的onNext方法，这样就能保证从observeOn(AndroidSchedulers.mainThread())执行后，下面的observer的onNext方法都是执行在主线程中。
       

      总结一下， observeOn()的作用就是通过主线程的Handler，调用的下一个Observer的onNext方法，这样就能实现下一个的observer的onNext方法的调用是主线程。
       

      四、Flowable背压
       

      1.背压的来源及解决方案
       

      当出现异步请求时，如果上游请求的速度远远超过下游处理的速度，就会出现事件积压在队列中，积压过多就会出现OOM。
       

      如何解决呢？
       

      为了解决这个问题设计了：下游提出自己的需求，上游按照下游的需求发出事件，如果上游超过了下游提出的请求，就会按照5种策略来处理。
       

      2.BaseEmitter继承AtomicLong，保证事件增减的原子性
       

      1.     abstract static class BaseEmitter
      2.     extends AtomicLong
      3.     implements FlowableEmitter, Subscription {
      4. }
      5.  
      6.         @Override
      7.         public final void request(long n) {
      8.             if (SubscriptionHelper.validate(n)) {
      9.                 BackpressureHelper.add(this, n);
      10.                 onRequested();
      11.             }
      12.         }
      13.  
      14. public static long add(AtomicLong requested, long n) {
      15.         for (;;) {
      16.             long r = requested.get();
      17.             if (r == Long.MAX_VALUE) {
      18.                 return Long.MAX_VALUE;
      19.             }
      20.             long u = addCap(r, n);
      21.             if (requested.compareAndSet(r, u)) {
      22.                 return r;
      23.             }
      24.         }
      25.     }
       

      发生器XXXEmitter通过request方法记录下游可以处理事件的个数，上游通过requtsted方法获取那个记录的个数,本质就是XXXEmitter是AtomicLong。
       

      request和requested使用：
       

      (1)当是在一个线程中，没有异步时:
       

      如观察者可接收事件数量 = 1，当被观察者发送第2个事件时，就会抛出异常
       

      1. Flowable.create(new FlowableOnSubscribe() { 
      2.             @Override 
      3.             public void subscribe(FlowableEmitter emitter) throws Exception { 
      4.  
      5.                 // 1. 调用emitter.requested()获取当前观察者需要接收的事件数量 
      6.                 Log.d(TAG, "观察者可接收事件数量 = " + emitter.requested()); 
      7.  
      8.                 // 2. 每次发送事件后，emitter.requested()会实时更新观察者能接受的事件 
      9.                 // 即一开始观察者要接收10个事件，发送了1个后，会实时更新为9个 
      10.                 Log.d(TAG, "发送了事件 1"); 
      11.                 emitter.onNext(1); 
      12.                 Log.d(TAG, "发送了事件1后, 还需要发送事件数量 = " + emitter.requested()); 
      13.  
      14.                 Log.d(TAG, "发送了事件 2"); 
      15.                 emitter.onNext(2); 
      16.                 Log.d(TAG, "发送事件2后, 还需要发送事件数量 = " + emitter.requested()); 
      17.  
      18.                 emitter.onComplete(); 
      19.             } 
      20.         }, BackpressureStrategy.ERROR) 
      21.                 .subscribe(new Subscriber() { 
      22.                     @Override 
      23.                     public void onSubscribe(Subscription s) { 
      24.  
      25.                         Log.d(TAG, "onSubscribe"); 
      26.                         s.request(1); // 设置观察者每次能接受1个事件 
      27.  
      28.                     } 
      29.  
      30.                     @Override 
      31.                     public void onNext(Integer integer) { 
      32.                         Log.d(TAG, "接收到了事件" + integer); 
      33.                     } 
      34.  
      35.                     @Override 
      36.                     public void onError(Throwable t) { 
      37.                         Log.w(TAG, "onError: ", t); 
      38.                     } 
      39.  
      40.                     @Override 
      41.                     public void onComplete() { 
      42.                         Log.d(TAG, "onComplete"); 
      43.                     } 
      44.                 });
       

      当FlowableEmitter.requested()减到0时，则代表观察者已经不可接收事件，这时就由策略决定如何处理多出的事件。
       

      (2).是异步时
       

      1.         Flowable.create(new FlowableOnSubscribe() {
      2.             @Override
      3.             public void subscribe(FlowableEmitter emitter) throws Exception {
      4.  
      5.                 // 1. 调用emitter.requested()获取当前观察者需要接收的事件数量
      6.                 Log.d(TAG, "观察者可接收事件数量 = " + emitter.requested());
      7.  
      8.                 // 2. 每次发送事件后，emitter.requested()会实时更新观察者能接受的事件
      9.                 // 即一开始观察者要接收10个事件，发送了1个后，会实时更新为9个
      10.  
      11.                 for (int i = 0; i < 129; i++) {
      12.                     Thread.sleep(100);
      13.                     Log.d(TAG, "发送了事件 " + i);
      14.                     emitter.onNext(i);
      15.                     Log.d(TAG, "发送了事件1后, 还需要发送事件数量 = " + emitter.requested());
      16.                 }
      17.                 emitter.onComplete();
      18.             }
      19.         }, BackpressureStrategy.ERROR)
      20.                 .subscribeOn(Schedulers.io())
      21.                 .observeOn(AndroidSchedulers.mainThread())
      22.                 .subscribe(new Subscriber() {
      23.                     @Override
      24.                     public void onSubscribe(Subscription s) {
      25.  
      26.                         Log.d(TAG, "onSubscribe");
      27.                         s.request(1); 
      28.  
      29.                     }
      30.  
      31.                     @Override
      32.                     public void onNext(Integer integer) {
      33.                         Log.i(TAG, "接收到了事件" + integer);
      34.                     }
      35.  
      36.                     @Override
      37.                     public void onError(Throwable t) {
      38.                         Log.w(TAG, "onError: ", t);
      39.                     }
      40.  
      41.                     @Override
      42.                     public void onComplete() {
      43.                         Log.d(TAG, "onComplete");
      44.                     }
      45.                 });
       

      是异步时，会有一个事件缓存池，默认是128，当出现当缓存区大小存满（默认缓存区大小 = 128）、被观察者仍然继续发送下1个事件时，就会触发策略处理
       

      3.如果上游发送事件的个数超过了下游需要的个数就会通过策略来处理
       

      1.     abstract static class NoOverflowBaseAsyncEmitter extends BaseEmitter {
      2.  
      3.         private static final long serialVersionUID = 4127754106204442833L;
      4.  
      5.         NoOverflowBaseAsyncEmitter(Subscribersuper T> actual) {
      6.             super(actual);
      7.         }
      8.  
      9.         @Override
      10.         public final void onNext(T t) {
      11.             if (isCancelled()) {
      12.                 return;
      13.             }
      14.  
      15.             if (t == null) {
      16.                 onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
      17.                 return;
      18.             }
      19.  
      20.             if (get() != 0) {
      21.                 actual.onNext(t);
      22.                 BackpressureHelper.produced(this, 1);
      23.             } else {
      24.                 onOverflow();
      25.             }
      26.         }
      27.  
      28.         abstract void onOverflow();
      29.     }
       

      我们可以看到NoOverflowBaseAsyncEmitter继承于BaseEmitter，同时还实现了onNext方法。从这里，我们可以看出AtomicLong的作用了，当调用一次Emitter的onNext方法时，先判断当前值是否为0，如果不为0，那么调用Subscriber的onNext方法，同时使用BackpressureHelper使当前的值减一；如果当前的值已经为0了，会调用onOverflow方法，此时根据不同的策略，onOverflow方法实现就不尽相同。
       

      注意如果不调用reqeust方法，默认为0.
       

      4.五种策略
       

      (1).模式1：BackpressureStrategy.ERROR  
       

      问题：发送事件速度 ＞ 接收事件 速度，即流速不匹配
       

       
 
      具体表现：出现当缓存区大小存满（默认缓存区大小 = 128）、被观察者仍然继续发送下1个事件时 
       

       

      处理方式：直接抛出异常MissingBackpressureException
       

      (2).模式2：BackpressureStrategy.MISSING
       

      问题：发送事件速度 ＞ 接收事件 速度，即流速不匹配
       

       
 
      具体表现是：出现当缓存区大小存满（默认缓存区大小 = 128）、被观察者仍然继续发送下1个事件时 
       

       

      处理方式：友好提示：缓存区满了
       

      (3).模式3：BackpressureStrategy.BUFFER
       

      问题：发送事件速度 ＞ 接收事件 速度，即流速不匹配 
       

       
 
      具体表现是：出现当缓存区大小存满（默认缓存区大小 = 128）、被观察者仍然继续发送下1个事件时
       

       

      处理方式：将缓存区大小设置成无限大 
       

      •  
        即被观察者可无限发送事件观察者，但实际上是存放在缓存区 
         
      •  
        但要注意内存情况，防止出现OOM
         
       

      可以接收超过原先缓存区大小（128）的事件数量了 
       

      (4).模式4： BackpressureStrategy.DROP
       

      问题：发送事件速度 ＞ 接收事件 速度，即流速不匹配 
       

       
 
      具体表现是：出现当缓存区大小存满（默认缓存区大小 = 128）、被观察者仍然继续发送下1个事件时
       

       

      处理方式：超过缓存区大小（128）的事件丢弃 
       

      如发送了150个事件，仅保存第1 - 第128个事件，第129 -第150事件将被丢弃
       

       被观察者一下子发送了150个事件，点击按钮接收时观察者接收了128个事件；再次点击接收时却无法接受事件，这说明超过缓存区大小的事件被丢弃了。
       

      (5).模式5：BackpressureStrategy.LATEST
       

      问题：发送事件速度 ＞ 接收事件 速度，即流速不匹配 
       

       
 
      具体表现是：出现当缓存区大小存满（默认缓存区大小 = 128）、被观察者仍然继续发送下1个事件时
       

       

      处理方式：只保存最新（最后）事件，超过缓存区大小（128）的事件丢弃 
       

      即如果发送了150个事件，缓存区里会保存129个事件（第1-第128 + 第150事件）
       

      被观察者一下子发送了150个事件，点击按钮接收时观察者接收了128个事件；
       

      再次点击接收时却接收到1个事件（第150个事件），这说明超过缓存区大小的事件仅保留最后的事件（第150个事件）
       

      
                
                    
                

                
    39. 

                    相关阅读:
      
                    
实习日报-2022-7-29                            
      
汽车虚拟仿真视频数据理解--CLIP模型原理                            
      
网络面试-0x12 UDP和TCP的区别以及应用场景                            
      
gpt-4o考场安排                            
      
MacOS安装conda                            
      
SpringBoot整合JUnit                            
      
paddlepaddle-gpu安装                            
      
现在学RPA，还有前途吗，会不会太卷？                            
      
React：我们即将和后端 API 告别？                            
      
Ajax——AJAX实现省市联动                            
      
                          
                
      40. 
                
    40. 
                    原文地址：https://blog.csdn.net/m0_37707561/article/details/126890656
                
      41.