android专题研究--内存泄漏（leakcanary用法与实现原理）

关于android性能分析，近期看了不少文章，但看了不代表自己会了，所以接下来会对自己看的文章进行总结，并加上自己的实践。这篇文章主要对google发布的leakcanary检测内存泄漏的使用方法，实现原理，使用注意事项，实例分析进行了总结。

一、使用方法

1. 引入包

在工作build.gradle中引入leakcanary的包；

debugCompile 'com.squareup.leakcanary:leakcanary-android:1.5.1'releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5.1'

或是不区分build Type

compile 'com.squareup.leakcanary:leakcanary-android:1.5.1'

2. 监测Activity

在Application文件中定义RefWatcher对象，调用install方法，即可监测到Activity的内存泄漏问题；

public class ExampleApplication extends Application {  public static RefWatcher getRefWatcher(Context context) {    ExampleApplication application = (ExampleApplication) context.getApplicationContext();    return application.refWatcher;  }  private RefWatcher refWatcher;  @Override public void onCreate() {    super.onCreate();    refWatcher = LeakCanary.install(this);//LeakCanary.install方法会返回一个预定义的RefWatcher，也会启用一个ActivityRefWatcher，用于自动监控调用Activity.onDestory()之后泄露的activity  }}

3. 监测Fragment

要监测Fragment的内存泄漏问题，获取Application中的RefWatcher对象，在onDestroy方法中调用其watch方法，检测那些本该回收的对象而没有被回收引发的内存泄漏；

public abstract class BaseFragment extends Fragment {  @Override public void onDestroy() {    super.onDestroy();    RefWatcher refWatcher = ExampleApplication.getRefWatcher(getActivity());    refWatcher.watch(this);//使用RefWatcher监控那些本该被回收的对象  }}

二、实现原理

1. RefWatcher.watch()创建KeyedWeakReference对象关联被监控对象

先来看下RefWatcher.watch(Object watchedReference)方法，它会调用内部的watch(Object watchedReference, String referenceName)方法。

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

也就是具体实现是在带两个参数的watch方法中，该方法会创建一个KeyedWeakReference对象，用于关联到要被监控的对象。

public void watch(Object watchedReference, String referenceName) {        if(this != DISABLED) {            ...            KeyedWeakReference reference = new KeyedWeakReference(watchedReference, key, referenceName, this.queue);//创建KeyedWeakReference对象关联到被监测对象            this.ensureGoneAsync(watchStartNanoTime, reference);        }    }

2. RefWatcher.ensureGone()方法在后台线程检查引用是否被清除，没有则调用GC回收

我们再来看下ensureGoneAsync方法，该方法开启线程池，在子线程中调用ensureGone方法，ensureGone方法主要作用是：在后台线程中检查引用是否被清除，没有则调用GC。

private void ensureGoneAsync(final long watchStartNanoTime, final KeyedWeakReference reference) {        this.watchExecutor.execute(new Retryable() {            public Result run() {                return RefWatcher.this.ensureGone(reference, watchStartNanoTime);            }        });    }    Result ensureGone(KeyedWeakReference reference, long watchStartNanoTime) {        long gcStartNanoTime = System.nanoTime();        long watchDurationMs = TimeUnit.NANOSECONDS.toMillis(gcStartNanoTime - watchStartNanoTime);        this.removeWeaklyReachableReferences();//清除弱引用        if(this.debuggerControl.isDebuggerAttached()) {            return Result.RETRY;        } else if(this.gone(reference)) {//如果引用被回收了，直接返回            return Result.DONE;        } else {            this.gcTrigger.runGc();//调用GC回收对象            this.removeWeaklyReachableReferences();            if(!this.gone(reference)) {//如果该引用对象无法被清除                long startDumpHeap = System.nanoTime();                long gcDurationMs = TimeUnit.NANOSECONDS.toMillis(startDumpHeap - gcStartNanoTime);                //把heap内存dump到APP对应的文件系统中一个.hprof文件中                File heapDumpFile = this.heapDumper.dumpHeap();                if(heapDumpFile == HeapDumper.RETRY_LATER) {                    return Result.RETRY;                }                long heapDumpDurationMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startDumpHeap);                //调用另一个进程中HeapAnalyzerService的HeapAnalyzer进行解析.hprof文件                this.heapdumpListener.analyze(new HeapDump(heapDumpFile, reference.key, reference.name, this.excludedRefs, watchDurationMs, gcDurationMs, heapDumpDurationMs));            }            return Result.DONE;        }    }

3. 若引用未清除，通过HeapAnalyzerService的onHandleIntent把引用的heap内存dump到.hprof文件中

ensureGone方法中倒数第二条语句会调用ServiceHeapDumpListener的analyze方法，该方法调用HeapAnalyzerService开启后台线程先保存引用的heap内存情况

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

HeapAnalyzerService是一个继承IntentService的类，它的runAnalysis方法，会启动服务；

 public static void runAnalysis(Context context, HeapDump heapDump, Class<? extends AbstractAnalysisResultService> listenerServiceClass) {        Intent intent = new Intent(context, HeapAnalyzerService.class);        intent.putExtra("listener_class_extra", listenerServiceClass.getName());        intent.putExtra("heapdump_extra", heapDump);        context.startService(intent);    }

HeapAnalyzerService先会将引用的heap内存dump到系统文件.prof文件中， 我们来看看它的onHandleIntent方法实现：

protected void onHandleIntent(Intent intent) {        if(intent == null) {            CanaryLog.d("HeapAnalyzerService received a null intent, ignoring.", new Object[0]);        } else {            String listenerClassName = intent.getStringExtra("listener_class_extra");            HeapDump heapDump = (HeapDump)intent.getSerializableExtra("heapdump_extra");            HeapAnalyzer heapAnalyzer = new HeapAnalyzer(heapDump.excludedRefs);//根据heapDump的引用新建一个HeapAnalyzer对象            AnalysisResult result = heapAnalyzer.checkForLeak(heapDump.heapDumpFile, heapDump.referenceKey);//调用HeapAnalyzer的方法解析.prof文件            AbstractAnalysisResultService.sendResultToListener(this, listenerClassName, heapDump, result);//找到内存泄漏引用链后，会调用AbstractAnalysisResultService的实现类DisplayLeakService,将结果以通知的形式展示出来        }    }

4. 通过HeapAnalyzer.checkForLeak方法使用HAHA解析.hprof文件

我们进入HeapAnalyzer类查看它的checkForLeak方法，发会新建一个解析器，并解析出引用链

public AnalysisResult checkForLeak(File heapDumpFile, String referenceKey) {       MemoryMappedFileBuffer e = new MemoryMappedFileBuffer(heapDumpFile);    HprofParser parser = new HprofParser(e);//新建HprofParser解析器对象    Snapshot snapshot = parser.parse();//对生成的.hprof文件解析并生成快照}

5. 根据referenceKey找到KeyedWeakReference，定位内存泄漏引用链

仍在HeapAnalyzer类的checkForLeak方法中

Instance leakingRef = this.findLeakingReference(referenceKey, snapshot);

6. 计算到GCroots的最短强引用路径，并确定是否是泄露，如果是则建立导致泄露的引用链

this.deduplicateGcRoots(snapshot);//计算到GCroots的引用路径return leakingRef == null?AnalysisResult.noLeak(this.since(analysisStartNanoTime)):this.findLeakTrace(analysisStartNanoTime, snapshot, leakingRef);//如果KeyedWeakReference存在，说明是内存泄漏，建立导到泄漏的引用链

7. 引用链传递到APP进程中的DisplayLeakService， 并以通知的形式展示出来

在HeapAnalyzerService的onHandleIntent的最后一句中,它会将引用链传递到DisplayLeakService中。

AbstractAnalysisResultService.sendResultToListener(this, listenerClassName, heapDump, result);//找到内存泄漏引用链后，会调用AbstractAnalysisResultService的实现类DisplayLeakService,将结果以通知的形式展示出来

最后调用了DisplayLeakService.onHeapAnalyzed方法,将内存泄漏的引用链发送到通知栏。

LeakCanaryInternals.showNotification(this, contentTitle, contentText, pendingIntent, notificationId1);

三、 使用注意事项（leakcanary引入方式不对可能导致不起作用）

1. 包的引入方式

随着组件化越来越流行，大家的工程可能不只一个module，一般会包含一个主module(工程入口，application)， 一个基础包basemodule(library)和若干个子module(library)，可能每个module都会依赖basemodule，所以一般依赖的第三方库一般都会写在basemodule的build.gradle中，这样也是为了避免多个module重复引用第三方库。
但是在引入第三方库时，有不同的引入形式，有以下六种：
1) compile：对所有的build type以及favlors都会参与编译并且打包到最终的apk文件中。
2) Provided：对所有的build type以及favlors只在编译时使用，类似eclipse中的external-libs,只参与编译，不打包到最终apk。
3) APK：只会打包到apk文件中，而不参与编译，所以不能再代码中直接调用jar中的类或方法，否则在编译时会报错
4) Test compile：仅仅是针对单元测试代码的编译编译以及最终打包测试apk时有效，而对正常的debug或者release apk包不起作用。
5) Debug compile：仅仅针对debug模式的编译和最终的debug apk打包。
6) Release compile：仅仅针对Release 模式的编译和最终的Release apk打包。
leakcanary官方建议用以下两种引入方式：

debugCompile 'com.squareup.leakcanary:leakcanary-android:1.5.1'releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5.1'

如果你把这两行代码写到basemodule的build.gradle中，会发现leakcanary不起作用，不起作用可以从以下几方面进行判断：
（1) 从应用图标来看，按道理如果工程引入了leakcanary，会出现一个leakcanary的应用图标，黄色图标包含一个感吧号的，如果没有代表你工程没有正确引用leakcanary；
（2) 将apk包解压缩，查看leakcanary相关代码，如果没有，说明你的工程没有把leakcanary打包进去，这样肯定也不会起作用；
（3) 自己写一个内存泄漏的代码，看看leakcanary是否能会弹出freeze窗口，如果没有，说明leakcanary没有被正常引入工程中。

2. leakcanary不起作用原因&怎么才是正确的引入方式

2.1 为什么leakcanary不起作用呢？

按道理在basemodule里引入了leakcanary包，相应依赖它的父module也自动引入leakcanary包，可为什么没有起作用，笔者上网查了一些资料，觉得是子module通过debug或是release引入的第三方库，对于父module只对编译有效，但是不会打进父module的apk包中。

2.2 那怎么才是正确的引入方式呢？

将以下引入的module的语句写到app的 build.gradle文件中。

debugCompile 'com.squareup.leakcanary:leakcanary-android:1.5.1'releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5.1'

或是引入leakcanary通过

compile 'com.squareup.leakcanary:leakcanary-android:1.5.1'

引入，但记得release包把它注释掉，要不用户体验很不好。

四、 实例分析

如我在工程中通过上面的正确引入方式将leakcanary引入到工程中，会发现在应用图标旁边出现了一个如下图标：

我们正常运行自己的应用，如果应用发生了内存泄漏，会出app freeze页面，应用暂停几S，应该是等待leakcanary将内存泄漏文件导出：

我们可以进入桌面launcher点击上面leakcanary的应用图标，查看内存泄漏发生的类及引用路径，如下图是内存泄漏的列表

点击查看详情

可以看到我这个内存泄漏发生在QuestionListActivity这个类里，它的实例被BaseRequestFunImpl类中的静态变量toast持有，toast的生命周期比QuestionListActivity长，导到QuestionListActivity生命周期结束时，也不能被回收。我们进入BaseRequestFunImpl类查看具体的代码。

public class BaseRequestFunImpl {    private static Toast toast;//静态变量    private static View toastview;    public static void getToast(Context context) {        if (toast == null) {        //toast持有了context实例            toast = new Toast(context);        }        if (toastview == null) {            toastview = Toast.makeText(context, "", Toast.LENGTH_SHORT).getView();        }        toast.setView(toastview);    }    public static void showToast(String message, Context mContext) {        try {            getToast(mContext);            toast.setText(message);            toast.setDuration(Toast.LENGTH_SHORT);            toast.show();        } catch (Exception e) {            e.printStackTrace();        }    }    public static void fetchServiceData(RequestEnvelope requestEnvelope, RxAppCompatActivity activity, JxhdServiceCallback callback) {        JXHDRetrofitGenerator.getJxhdInterfaceFun().queryJXHDService(requestEnvelope)                .subscribeOn(Schedulers.io())                .observeOn(AndroidSchedulers.mainThread())                .compose(activity.bindUntilEvent(ActivityEvent.DESTROY))                .doAfterTerminate(()->LoadingDialog.cancelDialogForLoading())                .subscribe(responseEnvelope -> callback.response(responseEnvelope), throwable -> {                    LoadingDialog.cancelDialogForLoading(); //将activity实例传给了静态变量toast                   showToast(activity.getString(R.string.failure), activity);                });    }}

代码中确实是静态变量持了类的实例，导到类生命周期结束时也无法被GC回收，导致内存泄漏，找到问题出处，接下来就是撸起袖子解决问题了。
toast的实例化可以使用Application的实例，这里只要把getToast方法改成如下即可：

public static void getToast(Context context) {        if (toast == null) {            toast = new Toast(context.getApplicationContext());        }        if (toastview == null) {            toastview = Toast.makeText(context.getApplicationContext(), "", Toast.LENGTH_SHORT).getView();        }        toast.setView(toastview);    }

这样就解决了内存泄漏问题。

总结：

本文主要讲述了leakcanary检测内存泄漏的使用方法，实现原理，使用注意事项，文末用一个实例对leakcanary的使用方法进行了实践。leakcanary确实是个好东西，但我们不能依赖它，应该根据平时检测出来的内存泄漏点，对自己平时编程习惯进行改进，争取写出不引发内存泄漏的代码。