RxJava AutoDispose原理解析

概述

最近的项目采用AutoDispose解决RxJava内存泄漏的问题.相对于让组件继承RxActivity或者RxFragment,使用AutoDispose只需要简单地加上.`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this))),就能非常漂亮并且保持较少侵入性的解决内存泄漏问题.当然本篇文章的重点不在于讲述AutoDispose如何使用,而是阐述AutoDispose如何通过监听Lifecycle来实现dispose.

必备的知识体系

在讲述原理之前,需要确保具有以下知识点的储备：

Lifecycle ，通过实现LifecycleObserver的方式订阅Lifecycle的事件,订阅者不会强引用lifecycle本身；
RxJava2，了解Observable的链式引用原理.以及map、filter等操作符;

Lifecycle监听生命周期

通过@OnLifecycleEvent注解可以订阅Lifecycle的特定事件，同时订阅者不会强引用Lifecycle本身,从源码来看:比如SupportActivity,在调用getLifecycle时返回的是LifecycleRegistry,里面维持的是对Activity本身的弱引用.

public class MyObserver implements LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void onResume() {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void onPause() {
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    public void onDestroy() {
    }    
}
aLifecycleOwner.getLifecycle().addObserver(new MyObserver());

RxJava的内存泄漏场景

当RxJava在异步线程中执行耗时任务(比如网络请求、IO等),在该任务未结束前由于持有Activity的Context将导致Activity无法被正常销毁。从代码来看,Observable.create创建了一个ObservableCreate(继承自Observable),该Observable在被订阅时会创建CreateEmitter来保存observer的实例.由于该实例引用Context,将使得Activity无法被回收.

    Observable.create{
        observer -> 
         observer.onNext("")
         observer.onComplete()
     }
     .observeOn(Schedulers.io())
     .subscribe{
         t->
         val context=this@DActivity
         Thread.sleep(5000)
         Log.d("",context.toString())
     }

AutoDispose在Activity::onDestroy时避免内存泄漏

AutoDispose在内部创建了ArchLifecycleObserver,采用Event.ON_ANY注解监听Lifecyc的生命周期
当Lifecycle发出ON_DESTROY事件时,ArchLifecycleObserver转发该事件给特定observer,该observer通过filter限定Event.ON_DESTROY事件通过
随后当Activity销毁时,Lifecycle发送事件给``ArchLifecycleObserver··,并调用onDispose方法取消对Lifecycle的监听。最后回调至ObservableCreate在订阅时创建的CreateEmitter的dispose方法,将CreateEmitter本身赋值为DISPOSED,销毁observer实例.

AutoDispose的创建

首先,AutoDispose会获取当前Context的lifecycle,并对应地创建一个observer用于监听lifecycle的变化。随后会例如下面产生的一个序列图:

AutoDispose的创建流程

图1:AutoDispose的创建流程

首先,AutoDispose会调用当前LifecycleOwner的getLifecycle,实现如下所示:

  public static AndroidLifecycleScopeProvider from(LifecycleOwner owner) {
    return from(owner.getLifecycle());
  }

在本文中,LifecycleOwner的实例是Activity,故调用getLifecycle返回的是LifecycleRegistry.随后调用from(lifecycle, DEFAULT_CORRESPONDING_EVENTS)创建AndroidLifecycleScopeProvider,如下所示:

  public static AndroidLifecycleScopeProvider from(
          Lifecycle lifecycle,
          Function boundaryResolver) {
    return new AndroidLifecycleScopeProvider(lifecycle, boundaryResolver);
  }

DEFAULT_CORRESPONDING_EVENTS是AndroidLifecycleScopeProvider内部创建的一个Function,该Function的作用用于返回对应初始生命周期的结束生命周期,声明如下所示:

  private static final Function DEFAULT_CORRESPONDING_EVENTS =
      new Function() {
        @Override public Lifecycle.Event apply(Lifecycle.Event lastEvent) throws Exception {
          switch (lastEvent) {
            case ON_CREATE:
              return Lifecycle.Event.ON_DESTROY;
            case ON_START:
              return Lifecycle.Event.ON_STOP;
            case ON_RESUME:
              return Lifecycle.Event.ON_PAUSE;
            case ON_PAUSE:
              return Lifecycle.Event.ON_STOP;
            case ON_STOP:case ON_DESTROY:
            default:
            ...
          }}};

随后,AndroidLifecycleScopeProvider内部根据传入的lifecycle创建了一个observer,用于监听本文中Activity的生命周期,并对应地创建一个Observable用于监听lifecycle的变化,实现如下:

class LifecycleEventsObservable extends Observable {

  private final Lifecycle lifecycle;
  private final BehaviorSubject eventsObservable = BehaviorSubject.create();

  @SuppressWarnings("CheckReturnValue") LifecycleEventsObservable(Lifecycle lifecycle) {
    this.lifecycle = lifecycle;
  }

  Event getValue() {
    return eventsObservable.getValue();
  }

  /**
   * Backfill if already created for boundary checking. We do a trick here for corresponding events
   * where we pretend something is created upon initialized state so that it assumes the
   * corresponding event is DESTROY.
   */
  void backfillEvents() {
    @Nullable Lifecycle.Event correspondingEvent;
    switch (lifecycle.getCurrentState()) {
      case INITIALIZED:
        correspondingEvent = ON_CREATE;
        break;
      case CREATED:
        correspondingEvent = ON_START;
        break;
      case STARTED:
      case RESUMED:
        correspondingEvent = ON_RESUME;
        break;
      case DESTROYED:
      default:
        correspondingEvent = ON_DESTROY;
        break;
    }
    eventsObservable.onNext(correspondingEvent);
  }

  @Override protected void subscribeActual(Observer 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);
    }
  }

  static final class ArchLifecycleObserver extends MainThreadDisposable
      implements LifecycleObserver {
    private final Lifecycle lifecycle;
    private final Observer observer;
    private final BehaviorSubject eventsObservable;

    ArchLifecycleObserver(Lifecycle lifecycle, Observer observer,
        BehaviorSubject eventsObservable) {
      this.lifecycle = lifecycle;
      this.observer = observer;
      this.eventsObservable = eventsObservable;
    }

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

    @OnLifecycleEvent(Event.ON_ANY) void onStateChange(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);
      }
    }
  }
}

AutoDispose被订阅

本文中的示例代码如下:

Observable.create {
     observer ->
     observer.onNext("first")
     observer.onNext("second")
 }
 .`as`(AutoDispose.autoDisposable(AndroidLifecycleScopeProvider.from(this)))
 .subscribe {
     it->
     val context=this@MainActivity
     Log.d("",context.toString())
 }

as操作符以及AutoDispose的订阅流程如下所示:

在这里插入图片描述

图2:AutoDispose的订阅流程

首先,Observable::create会创建一个ObservableCreate对象,而AutoDispose.autoDisposable会创建AutoDisposeConverter对象.as操作符调用前面生成的AutoDisposeConverter的apply方法,由于这里传入的是Observable对象,故执行下列方法调用:

 public ObservableSubscribeProxy apply(Observable upstream) {
     //这里的scope对应的是之前调用deferredResolvedLifecycle返回的Maybe对象
     return (ObservableSubscribeProxy)upstream.to(new ObservableScoper(scope));
 }

Observable::to调用ObservableScoper的apply(observable)方法创建一个ObservableSubscribeProxy对象,声明如下:

public ObservableSubscribeProxy apply(final Observable observableSource)
      throws Exception {
    return new ObservableSubscribeProxy() {
      @Override public Disposable subscribe() {
        return new AutoDisposeObservable<>(observableSource, scope()).subscribe();
      }

      @Override public Disposable subscribe(Consumer onNext) {
        //observableSource -> 示例中通过Observable::create创建的ObservableCreate对象
        //scope() -> 调用deferredResolvedLifecycle生成的Maybe
        return new AutoDisposeObservable<>(observableSource, scope()).subscribe(onNext);
      }
    }
}

待ObservableSubscribeProxy创建完成后,as操作符调用完成。接着正式进入订阅流程。通过Consumer订阅,执行AutoDisposeObservable的subscribeActual方法,如下:

@Override protected void subscribeActual(Observer observer) {
  //source -> 实例中创建的ObservablCreate对象
  source.subscribe(new AutoDisposingObserverImpl<>(scope, observer));
}

创建AutoDisposingObserverImpl实例,并接着调用该实例的onSubscribe、onNext方法.

final class AutoDisposingObserverImpl extends AtomicInteger implements AutoDisposingObserver {
    //lifecycleDisposable -> 
    private final AtomicReference lifecycleDisposable = new AtomicReference<>();
    
    AutoDisposingObserverImpl(Maybe lifecycle, Observer delegate) {
      //lifecycle -> Maybe
      this.lifecycle = lifecycle;
      //delegate实际上为observer,因为在AutoDisposingObserverImpl代理了Observable的调用
      //所以此处命名为deletagete
      this.delegate = delegate;
    }
      
    @Override public void onSubscribe(final Disposable d) {
      //创建一个Observer对象
      DisposableMaybeObserver