2020-12-09

LeakCanary工作原理和源码解析

内存泄漏一直以来就是Android APP需要着重解决的点，而LeakCanary是一个开源的内存泄漏检测库，通过简单的配置就可以帮我们快速的获取和定位到内存泄漏的位置，这极大的提高了开发的效率和APP的性能。为了能更加好的理解Android中的内存管理机制，我们还是有必要了解下LeakCanary的工作原理的，本篇文章就来对LeakCanary的源码进行解析。

一、简单配置

在build.gradle中添加配置：
支持库的fragments
implementation 'com.squareup.leakcanary:leakcanary-support-fragment:1.6.2'

public class LeakApplication extends Application {

    private RefWatcher refWatcher;

    @Override
    public void onCreate() {
        super.onCreate();
        refWatcher = setupLeakCanary();
        //        refWatcher.watch(this);
    }

    private RefWatcher setupLeakCanary() {
        // 判断当前进程是否是LeakCanary用于分析heap内存的而创建的HeapAnalyzerService所在进程，
        // 如果是的话，则不进行Application中的初始化功能。
        if (LeakCanary.isInAnalyzerProcess(this)) {
            return RefWatcher.DISABLED;
        }
        // 进行LeakCanary的安装配置
        return LeakCanary.install(this);
    }

    public static RefWatcher getRefWatcher(Context context) {
        LeakApplication leakApplication = (LeakApplication) context.getApplicationContext();
        return leakApplication.refWatcher;
    }
}

二、源码解析

1、先从LeakCanary#install开始看起：

/**
 * Creates a {@link RefWatcher} that works out of the box, and starts watching activity
 * references (on ICS+).
 */
public static @NonNull RefWatcher install(@NonNull Application application) {
  return refWatcher(application).listenerServiceClass(DisplayLeakService.class)
      .excludedRefs(AndroidExcludedRefs.createAppDefaults().build())
      .buildAndInstall();
}

调用install方法，里面是链式调用，我们一个一个来分析

2、LeakCanary#refWatcher

public static @NonNull AndroidRefWatcherBuilder refWatcher(@NonNull Context context) {
  return new AndroidRefWatcherBuilder(context);
}

AndroidRefWatcherBuilder(@NonNull Context context) {
    // 这里只是保存了ApplicationContext的引用
  this.context = context.getApplicationContext();
}

refWatcher方法就是简单创建了一个AndroidRefWatcherBuilder对象。

3、AndroidRefWatcherBuilder#listenerServiceClass

public @NonNull AndroidRefWatcherBuilder listenerServiceClass(
    @NonNull Class listenerServiceClass) {
  return heapDumpListener(new ServiceHeapDumpListener(context, listenerServiceClass));
}

/** @see HeapDump.Listener */
public final T heapDumpListener(HeapDump.Listener heapDumpListener) {
    this.heapDumpListener = heapDumpListener;
    return self();
}

public ServiceHeapDumpListener(@NonNull final Context context,
      @NonNull final Class listenerServiceClass) {
    this.listenerServiceClass = checkNotNull(listenerServiceClass, "listenerServiceClass");
    this.context = checkNotNull(context, "context").getApplicationContext();
}

创建了ServiceHeapDumpListener对象并把DisplayLeakService传递给它的一个成员变量，然后把创建的ServiceHeapDumpListener赋值给AndroidRefWatcherBuilder的父类RefWatcherBuilder的成员变量listenerServiceClass，ServiceHeapDumpListener作用是接收一个head dump文件并启动服务（位于独立进程）对文件使用haha库进行解析，接下来可以看得到，这里先说下它的作用。

4、RefWatcherBuilder#excludedRefs

/** @see ExcludedRefs */
public final T excludedRefs(ExcludedRefs excludedRefs) {
  heapDumpBuilder.excludedRefs(excludedRefs);
  return self();
}

// com.squareup.leakcanary.HeapDump.Builder#excludedRefs
public Builder excludedRefs(ExcludedRefs excludedRefs) {
  this.excludedRefs = checkNotNull(excludedRefs, "excludedRefs");
  return this;
}

这个方法是用来记录Android SDK和一些手机厂商定制SDK的时候存在的内存泄漏情况，这些都会被LeakCanary的检测给过滤掉。

5、AndroidRefWatcherBuilder#buildAndInstall

public @NonNull RefWatcher buildAndInstall() {
  if (LeakCanaryInternals.installedRefWatcher != null) {
    throw new UnsupportedOperationException("buildAndInstall() should only be called once.");
  }
  // 1
  RefWatcher refWatcher = build();
  if (refWatcher != DISABLED) {
    LeakCanaryInternals.setEnabledAsync(context, DisplayLeakActivity.class, true);
    if (watchActivities) {
        // 2
      ActivityRefWatcher.install(context, refWatcher);
    }
    if (watchFragments) {
        // 3
      FragmentRefWatcher.Helper.install(context, refWatcher);
    }
  }
  LeakCanaryInternals.installedRefWatcher = refWatcher;
  return refWatcher;
}

1、RefWatcherBuilder#build

public final RefWatcher build() {
  if (isDisabled()) {
    return RefWatcher.DISABLED;
  }

  if (heapDumpBuilder.excludedRefs == null) {
    heapDumpBuilder.excludedRefs(defaultExcludedRefs());
  }

  HeapDump.Listener heapDumpListener = this.heapDumpListener;
  if (heapDumpListener == null) {
    heapDumpListener = defaultHeapDumpListener();
  }

  DebuggerControl debuggerControl = this.debuggerControl;
  if (debuggerControl == null) {
    debuggerControl = defaultDebuggerControl();
  }

  HeapDumper heapDumper = this.heapDumper;
  if (heapDumper == null) {
    heapDumper = defaultHeapDumper();
  }

  WatchExecutor watchExecutor = this.watchExecutor;
  if (watchExecutor == null) {
    watchExecutor = defaultWatchExecutor();
  }

  GcTrigger gcTrigger = this.gcTrigger;
  if (gcTrigger == null) {
    gcTrigger = defaultGcTrigger();
  }

  if (heapDumpBuilder.reachabilityInspectorClasses == null) {
    heapDumpBuilder.reachabilityInspectorClasses(defaultReachabilityInspectorClasses());
  }

  return new RefWatcher(watchExecutor, debuggerControl, gcTrigger, heapDumper, heapDumpListener,
      heapDumpBuilder);
}

可以看到，build方法是通过建造者模式构建RefWatcher，在RefWatcher的构造器中传递了多个参数：

• watchExecutor：实现类是AndroidWatchExecutor，线程控制器，在onDestroy之后且主线程是空闲状态时执行内存泄漏检测。
• debuggerControl：判断是否处于调试模式，调试模式中不会进行内存泄漏检测。
• gcTrigger：用来触发gc操作。
• heapDumper：实现类是AndroidHeapDumper，用来生成hprof文件。
• heapDumpListener：这个字段就是上面说到的ServiceHeapDumpListener，封装了DisplayLeakService，主要用来开启一个HeapAnalyzerService服务对hprof文件使用haha库进行解析，最后通知会DisplayLeakService弹出泄漏提醒弹窗。
• heapDumpBuilder.excludedRefs：就是我们上面说到的LeakCanary检测时可以忽略的泄漏路径。
• heapDumpBuilder.reachabilityInspectorClasses：用于进行可达性检测的类列表。

2、leakcanary.ActivityRefWatcher#install

public static void install(@NonNull Context context, @NonNull RefWatcher refWatcher) {
  Application application = (Application) context.getApplicationContext();
  ActivityRefWatcher activityRefWatcher = new ActivityRefWatcher(application, refWatcher);

  application.registerActivityLifecycleCallbacks(activityRefWatcher.lifecycleCallbacks);
}

private final Application.ActivityLifecycleCallbacks lifecycleCallbacks =
      new ActivityLifecycleCallbacksAdapter() {
        @Override public void onActivityDestroyed(Activity activity) {
          refWatcher.watch(activity);
        }
      };

这里主要实现了Application中的ActivityLifecycleCallbacks对Activity的生命周期进行监听，这样在Activity执行onDestroy之后调用refWatcher.watch(Activity)对Activity进行内存泄漏检测。

3、FragmentRefWatcher.Helper#install

public static void install(Context context, RefWatcher refWatcher) {
  List fragmentRefWatchers = new ArrayList<>();

  if (SDK_INT >= O) {
    // 1
    fragmentRefWatchers.add(new AndroidOFragmentRefWatcher(refWatcher));
  }

  try {
    Class fragmentRefWatcherClass = Class.forName(SUPPORT_FRAGMENT_REF_WATCHER_CLASS_NAME);
    Constructor constructor =
        fragmentRefWatcherClass.getDeclaredConstructor(RefWatcher.class);
    FragmentRefWatcher supportFragmentRefWatcher =
        (FragmentRefWatcher) constructor.newInstance(refWatcher);
    // 2
    fragmentRefWatchers.add(supportFragmentRefWatcher);
  } catch (Exception ignored) {
  }

  if (fragmentRefWatchers.size() == 0) {
    return;
  }

    // 3
  Helper helper = new Helper(fragmentRefWatchers);

  Application application = (Application) context.getApplicationContext();
  // 4
  application.registerActivityLifecycleCallbacks(helper.activityLifecycleCallbacks);
}

这个方法主要用来监视fragment的泄漏，在注释1中把标准的Fragment的RefWatcher类AndroidOFragmentRefWatcher添加到fragmentRefWatchers中，注释2是通过反射获取SupportFragmentRefWatcher添加到fragmentRefWatchers中，在注释3中创建helper，在注释4中调用了helper.activityLifecycleCallbacks。

private final Application.ActivityLifecycleCallbacks activityLifecycleCallbacks =
    new ActivityLifecycleCallbacksAdapter() {
      @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        for (FragmentRefWatcher watcher : fragmentRefWatchers) {
          watcher.watchFragments(activity);
        }
      }
    };

这里调用了watcher.watchFragments，这个watcher是AndroidOFragmentRefWatcher或者SupportFragmentRefWatcher，我们来看看AndroidOFragmentRefWatcher中watchFragments方法。

@Override public void watchFragments(Activity activity) {
  FragmentManager fragmentManager = activity.getFragmentManager();
  fragmentManager.registerFragmentLifecycleCallbacks(fragmentLifecycleCallbacks, true);
}

private final FragmentManager.FragmentLifecycleCallbacks fragmentLifecycleCallbacks =
      new FragmentManager.FragmentLifecycleCallbacks() {

        @Override public void onFragmentViewDestroyed(FragmentManager fm, Fragment fragment) {
          View view = fragment.getView();
          if (view != null) {
            refWatcher.watch(view);
          }
        }

        @Override
        public void onFragmentDestroyed(FragmentManager fm, Fragment fragment) {
          refWatcher.watch(fragment);
        }
      };

通过当前传入的activity获取到FragmentManager，并调用registerFragmentLifecycleCallbacks进行监听检测，也就是在onFragmentViewDestroyed和onFragmentDestroyed分别使用refWatcher.watch(view)和refWatcher.watch(fragment)进行内存泄漏的检测。

---

6、RefWatcher#watch(java.lang.Object)

public void watch(Object watchedReference) {
  watch(watchedReference, "");
}

public void watch(Object watchedReference, String referenceName) {
  if (this == DISABLED) {
  return;
  }
  checkNotNull(watchedReference, "watchedReference");
  checkNotNull(referenceName, "referenceName");
  final long watchStartNanoTime = System.nanoTime();
  // 使用随机的UUID保证了每个检测对象对应的key的唯一性
  String key = UUID.randomUUID().toString();
  // 将key加入到set集合retainedKeys中，在检测对象是否泄漏的情况下会用的上
  retainedKeys.add(key);
  // 1
  final KeyedWeakReference reference = 
                    new KeyedWeakReference(watchedReference, key, referenceName, queue);
  // 2
  ensureGoneAsync(watchStartNanoTime, reference);
}

1、com.squareup.leakcanary.KeyedWeakReference

final class KeyedWeakReference extends WeakReference