效能優化工具知識梳理(7) LeakCanary

澤毛發表於2017-12-21

一、概述

LeakCanary提供了一種很便捷的方式,讓我們在開發階段檢測記憶體洩漏問題,我們不需要自己去根據記憶體快照來分析記憶體洩漏的原因,所需要做的僅僅是在Debug包中整合它,它會自動地幫我們檢測記憶體洩漏,並給出導致洩漏的引用鏈。

二、整合

下面,就來看一下如何在專案當中整合它:

  • 第一步:需要引入遠端依賴,這裡我們引入了兩個,在release版本中,所有的呼叫都是空實現,這樣就會避免在release的版本中也在桌面生成一個洩漏檢測結果的圖示。
dependencies {
        //在 debug 版本中才會實現真正的功能
        debugCompile 'com.squareup.leakcanary:leakcanary-android:1.3'
        //在 release 版本中為空實現
        releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.3'
}
複製程式碼
  • 第二步:重寫Application,初始化一個全域性RefWatcher物件,它負責監視所有應當要被回收的物件:
public class LeakCanaryApplication extends Application {

    private RefWatcher mRefWatcher;

    @Override
    public void onCreate() {
        super.onCreate();
        mRefWatcher = LeakCanary.install(this);
    }

    public static RefWatcher getRefWatcher(Context context) {
        LeakCanaryApplication application = (LeakCanaryApplication) context.getApplicationContext();
        return application.mRefWatcher;
    }
}
複製程式碼
  • 第三步:在需要回收的物件上,新增監測程式碼,這裡我們以Activity為例就需要在它的onDestory()方法中加入監測的程式碼,我們通過單例持有Activity的引用,模擬了一種記憶體洩漏發生的場景:
public class LeakSingleton {

    private static LeakSingleton sInstance;
    private Context mContext;

    public static LeakSingleton getInstance(Context context) {
        if (sInstance == null) {
            sInstance = new LeakSingleton(context);
        }
        return sInstance;
    }

    private LeakSingleton(Context context) {
        mContext = context;
    }
}

public class LeakCanaryActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_leak_canary);
        //讓這個單例物件持有 Activity 的引用
        LeakSingleton.getInstance(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //在 onDestroy 方法中使用 Application 中建立的 RefWatcher 監視需要回收的物件
        LeakCanaryApplication.getRefWatcher(this).watch(this);
    }
}
複製程式碼

在退出應用程式之後,我們會發現在桌面上生成了一個新的圖示,點選圖示進入,就是LeakCanary為我們分析出的導致洩漏的引用鏈:

效能優化工具知識梳理(7)   LeakCanary
以上就是把LeakCanary整合到專案中的方法,下面,我們來討論一下它的實現原理。

三、原理

當呼叫了RefWatcher.watch()方法之後,會觸發以下邏輯:

  • 建立一個KeyedWeakReference,它內部引用了watch傳入的物件:
final KeyedWeakReference reference = new KeyedWeakReference(watchedReference, key, referenceName, this.queue);
複製程式碼
  • 在後臺執行緒檢查引用是否被清除:
 this.watchExecutor.execute(new Runnable() {
      public void run() {
           RefWatcher.this.ensureGone(reference, watchStartNanoTime);
      }
});
複製程式碼
  • 如果沒有清除,那麼首先呼叫一次GC,假如引用還是沒有被清除,那麼把當前的記憶體快照儲存到.hprof檔案當中,並呼叫heapdumpListener進行分析:
void ensureGone(KeyedWeakReference reference, long watchStartNanoTime) {
        long gcStartNanoTime = System.nanoTime();
        long watchDurationMs = TimeUnit.NANOSECONDS.toMillis(gcStartNanoTime - watchStartNanoTime);
        this.removeWeaklyReachableReferences();
        if(!this.gone(reference) && !this.debuggerControl.isDebuggerAttached()) {
            this.gcTrigger.runGc();
            this.removeWeaklyReachableReferences();
            if(!this.gone(reference)) {
                long startDumpHeap = System.nanoTime();
                long gcDurationMs = TimeUnit.NANOSECONDS.toMillis(startDumpHeap - gcStartNanoTime);
                File heapDumpFile = this.heapDumper.dumpHeap();
                if(heapDumpFile == null) {
                    return;
                }
                long heapDumpDurationMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startDumpHeap);
                this.heapdumpListener.analyze(new HeapDump(heapDumpFile, reference.key, reference.name, watchDurationMs, gcDurationMs, heapDumpDurationMs));
            }
        }
}
複製程式碼
  • 上面說到的heapdumpListener的實現類為ServiceHeapDumpListener,它會啟動內部的HeapAnalyzerService
 public void analyze(HeapDump heapDump) {
        Preconditions.checkNotNull(heapDump, "heapDump");
        HeapAnalyzerService.runAnalysis(this.context, heapDump, this.listenerServiceClass);
}
複製程式碼
  • 這是一個IntentService,因此它的onHandlerIntent方法是執行在子執行緒中的,在通過HeapAnalyzer分析完畢之後,把最終的結果傳回給App端展示檢測的結果:
   protected void onHandleIntent(Intent intent) {
        String listenerClassName = intent.getStringExtra("listener_class_extra");
        HeapDump heapDump = (HeapDump)intent.getSerializableExtra("heapdump_extra");
        AnalysisResult result = this.heapAnalyzer.checkForLeak(heapDump.heapDumpFile, heapDump.referenceKey);
        AbstractAnalysisResultService.sendResultToListener(this, listenerClassName, heapDump, result);
    }
複製程式碼
  • HeapAnalyzer會計算未能回收的引用到Gc Roots的最短引用路徑,如果洩漏,那麼建立導致洩漏的引用鏈並通過AnalysisResult返回:
    public AnalysisResult checkForLeak(File heapDumpFile, String referenceKey) {
        long analysisStartNanoTime = System.nanoTime();
        if(!heapDumpFile.exists()) {
            IllegalArgumentException snapshot1 = new IllegalArgumentException("File does not exist: " + heapDumpFile);
            return AnalysisResult.failure(snapshot1, this.since(analysisStartNanoTime));
        } else {
            ISnapshot snapshot = null;

            AnalysisResult className;
            try {
                snapshot = this.openSnapshot(heapDumpFile);
                IObject e = this.findLeakingReference(referenceKey, snapshot);
                if(e != null) {
                    String className1 = e.getClazz().getName();
                    AnalysisResult result = this.findLeakTrace(analysisStartNanoTime, snapshot, e, className1, true);
                    if(!result.leakFound) {
                        result = this.findLeakTrace(analysisStartNanoTime, snapshot, e, className1, false);
                    }

                    AnalysisResult var9 = result;
                    return var9;
                }

                className = AnalysisResult.noLeak(this.since(analysisStartNanoTime));
            } catch (SnapshotException var13) {
                className = AnalysisResult.failure(var13, this.since(analysisStartNanoTime));
                return className;
            } finally {
                this.cleanup(heapDumpFile, snapshot);
            }

            return className;
        }
    }
複製程式碼

四、自定義處理行為

預設LeakCanary是會在桌面生成一個圖示,點選圖示之後,會展示導致洩漏的引用鏈,有時候,我們希望把這些資訊上傳到伺服器中,那麼就需要自定義收到結果後的處理的行為,下面,我們看一下要怎麼做:

  • 第一步:繼承DisplayLeakService,進行自己的處理邏輯,這裡我們只是列印出洩漏的資訊,heapDump為對應的記憶體快照,result為分析的結果,leakInfo則是相關的資訊:
public class MyLeakUploadService extends DisplayLeakService {

    @Override
    protected void afterDefaultHandling(HeapDump heapDump, AnalysisResult result, String leakInfo) {
        if (!result.leakFound || result.excludedLeak) {
            return;
        }
        Log.d("MyLeakUploadService", "leakInfo=" + leakInfo);
    }

}
複製程式碼
  • 第二步:改變Application中初始化RefWatcher的方式,第二個引數中傳入我們自定義的Service類名:
public class LeakCanaryApplication extends Application {
    private RefWatcher mRefWatcher;
    @Override
    public void onCreate() {
        super.onCreate();
        mRefWatcher = LeakCanary.install(this, MyLeakUploadService.class);
    }
}
複製程式碼
  • 第三步:在AndroidManifest.xml中註冊自定義的Service
   <application>
        <service android:name=".leakcanary.MyLeakUploadService"/>
    </application>
複製程式碼
  • 最後,我們執行和之前一樣的操作,會看到在輸出臺上列印出了洩漏的分析結果:
    效能優化工具知識梳理(7)   LeakCanary

五、小結

在除錯階段,我們可以通過引入LeakCanary,讓它幫助我們排查出一些會導致記憶體洩漏的問題。

六、參考文獻

https://www.liaohuqiu.net/cn/posts/leak-canary-read-me/


更多文章,歡迎訪問我的 Android 知識梳理系列:

相關文章