优雅解决Rxjava内存泄漏问题autodispose源码详解

Rxjava想比大家基本都用过，它主要用了观察者模式，在使用的时候，例如在avtivity里面使用订阅了事件之后一定要在activity的onDestroy中取消订阅事件，不取消的话有可能存在内存泄漏的风险，例如被观察者里面的网络事件还没有处理完，用户直接点了后退。而autodispose框架就是专门用来优雅解决这种内存泄漏问题的方案。至于autodispose怎么用，大家直接看看github就可以了autodispose使用详解。

ok，接下来直接写一个kotlin扩展方法来直接使用autodispose，如下：

fun <T> Observable<T>.autoDisposeSubscribe(scopeProvider: ScopeProvider, observer: Observer<T>) {
    this.subscribeOn(Schedulers.io())
        .unsubscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .`as`(AutoDispose.autoDisposable(scopeProvider))
        .subscribe(observer)
}

其中scopeProvider是通过 AndroidLifecycleScopeProvider.from(view.getViewLifecycle())拿到的，对autodispose的真正使用是在`as`(AutoDispose.autoDisposable(scopeProvider))这个方法，那么接下来,来看一下这个框架的真正实现原理是什么？先来看一下AutoDispose.autoDisposable方法的实现:

 public static <T> AutoDisposeConverter<T> autoDisposable(final ScopeProvider provider) {
    checkNotNull(provider, "provider == null");
    return autoDisposable(completableOf(provider));
  }

这个方法先检查传进来的provider不为null，然后对provider装饰一层Rxjava的Completable的deferf(defer 操作符与create、just、from等操作符一样，是创建类操作符，不过所有与该操作符相关的数据都是在订阅时才生效的。)方法,接下来看一下as操作符又包装了一层什么数据,最终调用apply方法

 public final <R> R as(@NonNull SingleConverter<T, ? extends R> converter) {
        return ObjectHelper.requireNonNull(converter, "converter is null").apply(this);
    }

而它的真正实现类是AutoDisposeConverter类，也就是autoDisposable方法返回的,如下：

   public SingleSubscribeProxy<T> apply(final Single<T> upstream) {
        if (!AutoDisposePlugins.hideProxies) {
          return new AutoDisposeSingle<>(upstream, scope);
        }
        return new SingleSubscribeProxy<T>() {
          @Override
          public Disposable subscribe() {
            return new AutoDisposeSingle<>(upstream, scope).subscribe();
          }

          @Override
          public Disposable subscribe(Consumer<? super T> onSuccess) {
            return new AutoDisposeSingle<>(upstream, scope).subscribe(onSuccess);
          }

          @Override
          public Disposable subscribe(BiConsumer<? super T, ? super Throwable> biConsumer) {
            return new AutoDisposeSingle<>(upstream, scope).subscribe(biConsumer);
          }

          @Override
          public Disposable subscribe(
              Consumer<? super T> onSuccess, Consumer<? super Throwable> onError) {
            return new AutoDisposeSingle<>(upstream, scope).subscribe(onSuccess, onError);
          }

          @Override
          public void subscribe(SingleObserver<? super T> observer) {
            new AutoDisposeSingle<>(upstream, scope).subscribe(observer);
          }

          @Override
          public <E extends SingleObserver<? super T>> E subscribeWith(E observer) {
            return new AutoDisposeSingle<>(upstream, scope).subscribeWith(observer);
          }

          @Override
          public TestObserver<T> test() {
            TestObserver<T> observer = new TestObserver<>();
            subscribe(observer);
            return observer;
          }

          @Override
          public TestObserver<T> test(boolean dispose) {
            TestObserver<T> observer = new TestObserver<>();
            if (dispose) {
              observer.dispose();
            }
            subscribe(observer);
            return observer;
          }
        };
      }
省略若干行

最终调用的apply返回SingleSubscribeProxy类,也就是说最后的最外层订阅者是SingleSubscribeProxy，可以把Rxjava的操作符理解成装饰者模式，每一个操作符都是在原来的订阅者基础上装饰一层去做其他的事，比如线程切换，数据转换等等，那么最后调用订阅方法subscribe的就是SingleSubscribeProxy类,也就是调用了如下方法

  public void subscribe(SingleObserver<? super T> observer) {
            new AutoDisposeSingle<>(upstream, scope).subscribe(observer);
          }

也就是说最后调用subscribe方法的是AutoDisposeSingle订阅者，代码如下

 public final void subscribe(SingleObserver<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");

        observer = RxJavaPlugins.onSubscribe(this, observer);

        ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null SingleObserver. Please check the handler provided to RxJavaPlugins.setOnSingleSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");

        try {
            subscribeActual(observer);
        } catch (NullPointerException ex) {
            throw ex;
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            NullPointerException npe = new NullPointerException("subscribeActual failed");
            npe.initCause(ex);
            throw npe;
        }
    }

接下来调用subscribeActual方法，实现方法如下：

  @Override
  protected void subscribeActual(SingleObserver<? super T> observer) {
    source.subscribe(new AutoDisposingSingleObserverImpl<>(scope, observer));
  }

 

现在又成被装饰者SingleObserveOn调用了订阅，此时的被观察者将AutoDisposingSingleObserverImpl装饰一下,Rxjava调用确实有点绕,可以理解为Rxjava首先从最外层的装饰者开始调用，直到最内层的装饰者被调用，最后处理完信息交给观察者处理,最内层的一般就是Observable被观察者，当它处理数据之前会先一层层调用观察者的onSubscribe方法，当它处理完数据之后会调一层层调用观察者的onNext的方法或onError或onComplete或onSuccess，当然这是可以自己控制的，至于retrofit封装的Rxjava的数据适配器大家可以自己研究学习一下，那么最终onSubscrice会执行到AutoDisposingSingleObserverImpl这个类,如下：

public void onSubscribe(final Disposable d) {
    DisposableCompletableObserver o =
        new DisposableCompletableObserver() {
          @Override
          public void onError(Throwable e) {
            scopeDisposable.lazySet(AutoDisposableHelper.DISPOSED);
            AutoDisposingSingleObserverImpl.this.onError(e);
          }

          @Override
          public void onComplete() {
            scopeDisposable.lazySet(AutoDisposableHelper.DISPOSED);
            AutoDisposableHelper.dispose(mainDisposable);
          }
        };
    if (AutoDisposeEndConsumerHelper.setOnce(scopeDisposable, o, getClass())) {
      delegate.onSubscribe(this);
      scope.subscribe(o);
      AutoDisposeEndConsumerHelper.setOnce(mainDisposable, d, getClass());
    }
  }

此时会走到这个if判断里面

if (AutoDisposeEndConsumerHelper.setOnce(scopeDisposable, o, getClass())) {
      delegate.onSubscribe(this);
      scope.subscribe(o);
      AutoDisposeEndConsumerHelper.setOnce(mainDisposable, d, getClass());
    }

此处的scope就是它,也就是CompletableDefer，然后再调用它的调阅

 Completable.defer(
        () -> {
          try {
            return scopeProvider.requestScope();
          } catch (OutsideScopeException e) {
            Consumer<? super OutsideScopeException> handler =
                AutoDisposePlugins.getOutsideScopeHandler();
            if (handler != null) {
              handler.accept(e);
              return Completable.complete();
            } else {
              return Completable.error(e);
            }
          }
        });

订阅实现方法如下：

 protected void subscribeActual(CompletableObserver observer) {
        CompletableSource c;

        try {
            c = ObjectHelper.requireNonNull(completableSupplier.call(), "The completableSupplier returned a null CompletableSource");
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            EmptyDisposable.error(e, observer);
            return;
        }

        c.subscribe(observer);
    }

它内部又调用了包装类的call方法，然后通过返回的订阅者事件又调用了订阅,也就是说call方法最终是调用了scopeProvider.requestScope()返回订阅者,而scopeProvider的实现类是AndroidLifecycleScopeProvider,这确实比较绕，找起来容易找混，最终requestScope方法返回如下：

  public CompletableSource requestScope() {
    return LifecycleScopes.resolveScopeFromLifecycle(this);
  }

这个方法最终会调用到LifecycleScopes 的resolveScopeFromLifecycle方法

 public static <E> CompletableSource resolveScopeFromLifecycle(
      Observable<E> lifecycle, final E endEvent, @Nullable final Comparator<E> comparator) {
    Predicate<E> equalityPredicate;
    if (comparator != null) {
      equalityPredicate = e -> comparator.compare(e, endEvent) >= 0;
    } else {
      equalityPredicate = e -> e.equals(endEvent);
    }
    return lifecycle.skip(1).takeUntil(equalityPredicate).ignoreElements();
  }

其中lifecycle的实现类是LifecycleEventsObservable，这里判断了activity事件的生命周期并将ON_DESTROY的生命周期信号作为takeUntil的判断信号用来是否回调最后的观察者对象，通俗的讲就是如果当前activity或fragment的生命周期走到尽头，那么Rxjava的被观察者处理完事件后就没有必要通知观察者了。

看到这里，autodispose的流程原理已经理清，通俗的讲就是在Rxjava的调用链的通知环节中引入 LifecycleEventsObservable订阅者,并在订阅的时候绑定组件（可以是activity、fragment）的生命周期，也就是下面的代码：

protected void subscribeActual(Observer<? super Event> observer) {
    ArchLifecycleObserver archObserver =
        new ArchLifecycleObserver(lifecycle, observer, eventsObservable);
    observer.onSubscribe(archObserver);
    if (!isMainThread()) {
      observer.onError(
          new IllegalStateException("Lifecycles can only be bound to on the main thread!"));
      return;
    }
    lifecycle.addObserver(archObserver);
    if (archObserver.isDisposed()) {
      lifecycle.removeObserver(archObserver);
    }
  }

代码 lifecycle.addObserver(archObserver)就可以监听到组件生命周期,也就是ArchLifecycleObserver类的onStateChange方法

   @OnLifecycleEvent(Event.ON_ANY)
    void onStateChange(@SuppressWarnings("unused") LifecycleOwner owner, Event event) {
      if (!isDisposed()) {
        if (!(event == ON_CREATE && eventsObservable.getValue() == event)) {
          // Due to the INITIALIZED->ON_CREATE mapping trick we do in backfill(),
          // we fire this conditionally to avoid duplicate CREATE events.
          eventsObservable.onNext(event);
        }
        observer.onNext(event);
      }
    }
  }

每次生命周期改变的时候eventsObservable用来记录生命周期状态，observer用来处理生命周期是否该结束当前引用链（是否调用dispose方法），其中observer可以理解为包裹了AutoDisposingObserverImpl,而AutoDisposingObserverImpl又包裹了真正的观察者回调，而AutoDisposingObserverImpl又被lifecycle.skip(1).takeUntil(equalityPredicate).ignoreElements()方法装饰了几次，那么每次onNext的方法都会走

ObservableSkip->ObservableTakeUntilPredicate->ObservableIgnoreElementsCompletable->AutoDisposingObserverImpl->最终的观察者回调，那么这条链的任何一个环节只要加入回调暂停的话，那么真正的观察者的链就会停止,而被处理的这条链就是TakeUntilPredicateObserver处理的,如下代码：

  public void onNext(T t) {
            if (!done) {
                downstream.onNext(t);
                boolean b;
                try {
                    b = predicate.test(t);
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);
                    upstream.dispose();
                    onError(e);
                    return;
                }
                if (b) {
                    done = true;
                    upstream.dispose();
                    downstream.onComplete();
                }
            }
        }

每次事件过来后将会判断当前组件的生命周期是否到达最后，如果到达最后done为true，直接把上游的upstream中断调用dispose,之后调用ArchLifecycleObserver的onDispose方法，用来取消监听生命周期，既然生命周期已经结束就没有必要监听了

  protected void onDispose() {
      lifecycle.removeObserver(this);
    }

 

下游直接调用onComplete证明此次事件结束，当被观察者在子线程处理任务时就不会再向外层分发，从而起到阻断事件的作用，而下面的代码也在次结束，不会朝真正的观察者传递

  public void onError(Throwable t) {
            if (!done) {
                done = true;
                downstream.onError(t);
            } else {
                RxJavaPlugins.onError(t);
            }
        }

        @Override
        public void onComplete() {
            if (!done) {
                done = true;
                downstream.onComplete();
            }
        }

不得不说autodispose设计的非常巧妙，跟着引用链看源码很有可能转晕