「Leakcanary 源码分析」看这一篇就够了

image.png

「Leakcanary 」是我们经常用于检测内存泄漏的工具，简单的使用方式，内存泄漏的可视化，是我们开发中必备的工具之一。

分析源码之前

Leakcanary 大神的 github ，最好的老师。

一、使用

1、配置

dependencies {
  debugImplementation 'com.squareup.leakcanary:leakcanary-android:1.6.3'
  releaseImplementation 'com.squareup.leakcanary:leakcanary-android-no-op:1.6.3'
  // Optional, if you use support library fragments:
  debugImplementation 'com.squareup.leakcanary:leakcanary-support-fragment:1.6.3'
}

2、简单使用

public class ExampleApplication extends Application {

  @Override public void onCreate() {
    super.onCreate();
    if (LeakCanary.isInAnalyzerProcess(this)) {
      // This process is dedicated to LeakCanary for heap analysis.
      // You should not init your app in this process.
      return;
    }
    LeakCanary.install(this);
    // Normal app init code...
  }
}

超级简单的配置和使用方式。最后就会得出以下的事例说明。

image.png

二、准备工作

1、Reference

Reference 把内存分为 4 种状态，Active 、 Pending 、 Enqueued 、 Inactive。

• Active 一般说来内存一开始被分配的状态都是 Active
• Pending 快要放入队列（ReferenceQueue）的对象，也就是马上要回收的对象
• Enqueued 对象已经进入队列，已经被回收的对象。方便我们查询某个对象是否被回收
• Inactive 最终的状态，无法变成其他的状态。

2、ReferenceQueue

引用队列，在 Reference 被回收的时候，Reference 会被添加到 ReferenceQueue 中

3、如果检测一个对象是否被回收

需要采用 Reference + ReferenceQueue

• 创建一个引用队列 queue
• 创建 Reference 对象（通常用弱引用）并关联引用队列
• 在 Reference 被回收的时候，Reference 会被添加到 queue 中

//创建一个引用队列  
ReferenceQueue queue = new ReferenceQueue();  

// 创建弱引用，此时状态为Active，并且Reference.pending为空，
// 当前Reference.queue = 上面创建的queue，并且next=null  
// reference 创建并关联 queue
WeakReference reference = new WeakReference(new Object(), queue);  

// 当GC执行后，由于是弱引用，所以回收该object对象，并且置于pending上，此时reference的状态为PENDING  
System.gc();  
  
// ReferenceHandler从 pending 中取下该元素，并且将该元素放入到queue中，
//此时Reference状态为ENQUEUED，Reference.queue = ReferenceENQUEUED 
  
// 当从queue里面取出该元素，则变为INACTIVE，Reference.queue = Reference.NULL  
Reference reference1 = queue.remove();  

在 Reference 类加载的时候，Java 虚拟机会会创建一个最大优先级的后台线程，这个线程的工作就是不断检测 pending 是否为 null，如果不为 null，那么就将它放到 ReferenceQueue。因为 pending 不为 null，就说明引用所指向的对象已经被 GC，变成了不也达。

4、ActivityLifecycleCallbacks

用于监听所有 Activity 生命周期的回调方法。

  private final Application.ActivityLifecycleCallbacks lifecycleCallbacks =
      new Application.ActivityLifecycleCallbacks() {
        @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        }

        @Override public void onActivityStarted(Activity activity) {
        }

        @Override public void onActivityResumed(Activity activity) {
        }

        @Override public void onActivityPaused(Activity activity) {
        }

        @Override public void onActivityStopped(Activity activity) {
        }

        @Override public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        }

        @Override public void onActivityDestroyed(Activity activity) {
          ActivityRefWatcher.this.onActivityDestroyed(activity);
        }
      };

5、Heap Dump

Heap Dump也叫堆转储文件，是一个Java进程在某个时间点上的内存快照。

三、原理说明

1、监听 Activity 的生命周期。
2、在 onDestory 的时候，创建对应的 Actitity 的 Refrence 和 相应的 RefrenceQueue，启动后台进程去检测。
3、一段时间后，从 RefrenceQueue 中读取，如果有这个 Actitity 的 Refrence，那么说明这个 Activity 的 Refrence 已经被回收，但是如果 RefrenceQueue 没有这个 Actitity 的 Refrence 那就说明出现了内存泄漏。
4、dump 出 hprof 文件，找到泄漏路径。

分析源码

程序的唯一入口 LeakCanary.install(this);

1、install

DisplayLeakService 这个类负责发起 Notification 以及将结果记录下来写在文件里面。以后每次启动LeakAnalyzerActivity就从这个文件里读取历史结果，并展示给我们。

  public static RefWatcher install(Application application) {
    return install(application, DisplayLeakService.class);
  }

  public static RefWatcher install(Application application,
      Class listenerServiceClass) {
   //如果在主线程 那么返回一个无用的 RefWatcher  详解 1.1
    if (isInAnalyzerProcess(application)) {
      return RefWatcher.DISABLED;
    }
    //把 DisplayLeakActivity 设置为可用  用于显示 DisplayLeakActivity 就是我们看到的那个分析界面
    enableDisplayLeakActivity(application);
   // 详解 1.2
    HeapDump.Listener heapDumpListener =
        new ServiceHeapDumpListener(application, listenerServiceClass);
    //详解 2
    RefWatcher refWatcher = androidWatcher(application, heapDumpListener);
    详解 3
    ActivityRefWatcher.installOnIcsPlus(application, refWatcher);
    return refWatcher;
  }

1.1 isInAnalyzerProcess

因为 分析的进程是硬外一个独立进程 所以要判断是否是主进程，这个工作需要在 AnalyzerProcess 中进行。

  public static boolean isInAnalyzerProcess(Context context) {
    return isInServiceProcess(context, HeapAnalyzerService.class);
  }

把App 的进程 和 这个 Service 进程进行对比 。

  private static boolean isInServiceProcess(Context context,
      Class serviceClass) {
    PackageManager packageManager = context.getPackageManager();
    PackageInfo packageInfo;
    try {
      packageInfo = packageManager.getPackageInfo(context.getPackageName(), GET_SERVICES);
    } catch (Exception e) {
      Log.e("AndroidUtils", "Could not get package info for " + context.getPackageName(), e);
      return false;
    }
    String mainProcess = packageInfo.applicationInfo.processName;

    ComponentName component = new ComponentName(context, serviceClass);
    ServiceInfo serviceInfo;
    try {
      serviceInfo = packageManager.getServiceInfo(component, 0);
    } catch (PackageManager.NameNotFoundException ignored) {
      // Service is disabled.
      return false;
    }

    if (serviceInfo.processName.equals(mainProcess)) {
      Log.e("AndroidUtils",
          "Did not expect service " + serviceClass + " to run in main process " + mainProcess);
      // Technically we are in the service process, but we're not in the service dedicated process.
      return false;
    }

    int myPid = android.os.Process.myPid();
    ActivityManager activityManager =
        (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    ActivityManager.RunningAppProcessInfo myProcess = null;
   
    for (ActivityManager.RunningAppProcessInfo process : activityManager.getRunningAppProcesses()) {
      if (process.pid == myPid) {
        myProcess = process;
        break;
      }
    }
    if (myProcess == null) {
      Log.e("AndroidUtils", "Could not find running process for " + myPid);
      return false;
    }
 //把App 的进程 和 这个 Service 进程进行对比 
    return myProcess.processName.equals(serviceInfo.processName);
  }

1.2 ServiceHeapDumpListener

设置 DisplayLeakService 和 HeapAnalyzerService 的可用。
analyze 方法，开始分析 HeapDump。

public final class ServiceHeapDumpListener implements HeapDump.Listener {

  private final Context context;
  private final Class listenerServiceClass;

  public ServiceHeapDumpListener(Context context,
      Class listenerServiceClass) {
    LeakCanary.setEnabled(context, listenerServiceClass, true);
    LeakCanary.setEnabled(context, HeapAnalyzerService.class, true);
    this.listenerServiceClass = checkNotNull(listenerServiceClass, "listenerServiceClass");
    this.context = checkNotNull(context, "context").getApplicationContext();
  }

  @Override public void analyze(HeapDump heapDump) {
    checkNotNull(heapDump, "heapDump");
    HeapAnalyzerService.runAnalysis(context, heapDump, listenerServiceClass);
  }
}

2、RefWatcher

  private final Executor watchExecutor;
  private final DebuggerControl debuggerControl;
  private final GcTrigger gcTrigger;
  private final HeapDumper heapDumper;
  private final Set retainedKeys;
  private final ReferenceQueue