Android LeakCanary源码解析

以你之姓@ 2023-07-06 14:35 43阅读 0赞

LeakCanary原理：watch一个即将要销毁的对象  
1.在Activity 调用OnDestroy()之后将它放在一个WeakReference  
2.将这个WeakReference关联到一个ReferenceQueue  
3.查看ReferenceQueue是否存在Activity的引用  
4.如果该Activit泄漏了，Dump出heap信息，然后再去分析泄漏路径

要了解内存泄漏首先要了解内存  
内存分为：  
1.栈（stack）：存放基本类型和对象的引用  
2.堆（heap）：存放new出来，创建出来的对象或者数组，在堆中的内存是由Java虚拟机的垃圾回收器来管理的，JVM只有一个堆区，同时这个堆区会被所有线程所共享  
3.方法区（method）：方法区也可以称为静态区，被所有的线程共享的，方法区中还包含所有的class对象和静态变量

为什么会产生内存泄漏  
1.对象不再需要使用，在对象需要被回收的时候，有其它正在使用的对象在引用它，导致这个本该被回收的对象不能被回收，本该被回收的对象还在堆内存中，就产生了内存泄漏  
2.有些对象只有有限的生命周期，当这些生命周期很短的对象任务完成之后，就应该垃圾回收器回收，如果在这个对象的生命周期快被结束时，还被一系列的引用，就会导致内存泄漏

内存泄漏会导致什么问题  
随着泄漏的不断累积，可能会消耗完整个内存，导致OOM

说到了引用，就说下引用类型  
1.强引用（StrongReference）：正常使用的对象就是强引用，强引用垃圾回收器是不会去回收强引用的对象，当内存不足，虚拟机宁愿抛出OOM的错误  
2.软引用（SoftReference）：内存空间足够的话，垃圾回收器不会去回收软引用的对象；但是内存空间不够的情况下，就回去回收软引用引用的对象的内存，只要垃圾回器没有回收这个软引用的对象，这个对象还是可以被使用的  
3.弱引用（WeakReference）：当垃圾回收器，扫描内存的时候，这时候不去区分内存够不够，会直接回收弱引用的对象  
4.虚引用：形同虚设，不会决定一个对象的任何生命周期，垃圾回收器在任何情况下都可以回收

ReferenceQueue  
软引用或者弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个引用加入到与之关联的引用队列中

看下LeakCanary.install方法

public static @NonNull RefWatcher install(@NonNull Application application) { //RefWatcher类是用于启动ActivityRefWatcher，然后通过ActivityRefWatcher去监视Activity的回收情况
        return refWatcher(application).listenerServiceClass(DisplayLeakService.class)
            .excludedRefs(AndroidExcludedRefs.createAppDefaults().build())
            .buildAndInstall();
      }

看下buildAndInstall()方法

public RefWatcher buildAndInstall() { 
        RefWatcher refWatcher = build();//创建RefWatcher 对象
        if (refWatcher != DISABLED) { 
          LeakCanary.enableDisplayLeakActivity(context);//LeakCanary就是使用的时候，弹框，告诉我们哪里有内存泄漏，enableDisplayLeakActivity开启Activity
          ActivityRefWatcher.install((Application) context, refWatcher);
        }
        return refWatcher;
      }

看下 ActivityRefWatcher.install(context, refWatcher)方法

public static void install(Application application, RefWatcher refWatcher) { 
        new ActivityRefWatcher(application, refWatcher).watchActivities();
      }
      看下watchActivities()方法
       
    
    ```java
     public void watchActivities() { 
        stopWatchingActivities();
        application.registerActivityLifecycleCallbacks(lifecycleCallbacks);//重新注册activity的生命周期的Callback
      }

看下stopWatchingActivities()方法

public void stopWatchingActivities() { 
        application.unregisterActivityLifecycleCallbacks(lifecycleCallbacks);//反注册以前的Activity生命周期的Calback,也就是保证我们以前所做的内存泄漏的监听工作要删除
      }

看下activityRefWatcher.lifecycleCallbacks源码
    
    ```java
      private final Application.ActivityLifecycleCallbacks lifecycleCallbacks =
          new ActivityLifecycleCallbacksAdapter() {
            @Override public void onActivityDestroyed(Activity activity) {
              refWatcher.watch(activity);
            }
          };

看下ActivityLifecycleCallbacks

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);//将Activity的生命周期关联到ActivityRefWatcher类当中
            }
          };

看下onActivityDestroyed(activity)方法

void onActivityDestroyed(Activity activity) { 
        refWatcher.watch(activity);
      }

看下RefWatcher的成员变量

public final class RefWatcher { 
    
      public static final RefWatcher DISABLED = new RefWatcherBuilder<>().build();
    
      private final WatchExecutor watchExecutor;//用于去执行内存泄漏的检测用的
      private final DebuggerControl debuggerControl;//用于查询是否正在调试中，调试中就不会进行内存泄漏的检测判断
      private final GcTrigger gcTrigger;//用于处理GC的，判断内存泄漏之前，给泄漏对象一次机会，先调用一次GC，如果不GC就会把Dumper文件显示出来
      private final HeapDumper heapDumper;//Dumper出内存泄漏的堆文件
      private final Set<String> retainedKeys;//持有那些待检测的，以及那些产生内存泄漏的引用的key
      private final ReferenceQueue<Object> queue;//引用队列，主要是判断弱引用所持有的对象，是否已经被执行了GC垃圾回收
      private final HeapDump.Listener heapdumpListener;//主要是用于分析一些产生Heap文件的回调
      private final ExcludedRefs excludedRefs;//排除一些系统的bug引起的内存泄漏
                                          .
                                          .
                                          .
      }

看下 refWatcher.watch(activity)方法

public void watch(Object watchedReference) { 
        watch(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();
        String key = UUID.randomUUID().toString();//对Refenerence添加一个唯一的key值引用
        retainedKeys.add(key);//将唯一的key添加到前面说过的set集合当中
        final KeyedWeakReference reference =
            new KeyedWeakReference(watchedReference, key, referenceName, queue);//创建所需要的弱引用对象
    
        ensureGoneAsync(watchStartNanoTime, reference);//开启一个异步线程来分析，刚才所创建好的KeyedWeakReference
      }

看下ensureGoneAsync(watchStartNanoTime, reference)方法

private void ensureGoneAsync(final long watchStartNanoTime, final KeyedWeakReference reference) { 
        watchExecutor.execute(new Retryable() { 
          @Override public Retryable.Result run() { 
            return ensureGone(reference, watchStartNanoTime);
          }
        });
      }

看下ensureGone(reference, watchStartNanoTime)方法

Retryable.Result ensureGone(final KeyedWeakReference reference, final long watchStartNanoTime) { //用来确保Activity是否已经进入Gone状态，Gone表示Activity是否真的已经被回收了
        long gcStartNanoTime = System.nanoTime();
        long watchDurationMs = NANOSECONDS.toMillis(gcStartNanoTime - watchStartNanoTime);
    
        removeWeaklyReachableReferences();
    
        if (debuggerControl.isDebuggerAttached()) { //判断如果是出于处于调试状态的时候，就不会进行内存泄漏的分析
          return RETRY;
        }
        if (gone(reference)) { //如果当前对象已经可达，已经不会造成内存泄漏，这就是不属于内存泄漏的范围
          return DONE;
        }
        gcTrigger.runGc();//gcTrigger进行垃圾回收的对象，gcTrigger.runGc()如果当前对象没有改变它的可达状态，进行手动的垃圾回收
        removeWeaklyReachableReferences();//清除已经到达引用队列的弱引用，把已经回收的对象的Key，从Set对象中移除，剩下的Key保证都是未被回收的
        if (!gone(reference)) { //表示已经出现内存泄漏
          long startDumpHeap = System.nanoTime();
          long gcDurationMs = NANOSECONDS.toMillis(startDumpHeap - gcStartNanoTime);//用于计算调用watch这个方法到我们调用了GC垃圾回收总共所产生的时间
          File heapDumpFile = heapDumper.dumpHeap();//Dumper出我们所需要的内存泄漏文件
          if (heapDumpFile == RETRY_LATER) { 
            // Could not dump the heap.
            return RETRY;
          }
          long heapDumpDurationMs = NANOSECONDS.toMillis(System.nanoTime() - startDumpHeap);
          heapdumpListener.analyze( // heapdumpListener.analyze去真正分析内存泄漏，以及它的路径
              new HeapDump(heapDumpFile, reference.key, reference.name, excludedRefs, watchDurationMs,
                  gcDurationMs, heapDumpDurationMs));
        }
        return DONE;
      }

总结下：  
1.首先会创建一个ActivityRefWatcher,启动一个ActivityRefWatcher  
2.通过ActivityLifecycleCallbacks把activity的OnDestory生命周期关联  
3.最后在线程池中去开始分析内存泄漏

看下 heapdumpListener.analyze( new HeapDump(heapDumpFile, reference.key, reference.name, excludedRefs, watchDurationMs, gcDurationMs, heapDumpDurationMs));这个抽象方法的实现

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

看下 HeapAnalyzerService.runAnalysis(context, heapDump, listenerServiceClass);方法

public final class HeapAnalyzerService extends IntentService { //是个IntentService，最后会到 onHandleIntent(Intent intent)方法
    
      private static final String LISTENER_CLASS_EXTRA = "listener_class_extra";
      private static final String HEAPDUMP_EXTRA = "heapdump_extra";
    
      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);
      }
    
      public HeapAnalyzerService() { 
        super(HeapAnalyzerService.class.getSimpleName());
      }
    
      @Override protected void onHandleIntent(Intent intent) { 
        if (intent == null) { 
          CanaryLog.d("HeapAnalyzerService received a null intent, ignoring.");
          return;
        }
        String listenerClassName = intent.getStringExtra(LISTENER_CLASS_EXTRA);//获取runAnalysis(Context context, HeapDump heapDump, Class<? extends AbstractAnalysisResultService> listenerServiceClass)方法传进来的参数
        HeapDump heapDump = (HeapDump) intent.getSerializableExtra(HEAPDUMP_EXTRA);
    
        HeapAnalyzer heapAnalyzer = new HeapAnalyzer(heapDump.excludedRefs);//用于分析堆内存的，heapDump.excludedRefs排除系统Bug所引起的内存泄漏
    
        AnalysisResult result = heapAnalyzer.checkForLeak(heapDump.heapDumpFile, heapDump.referenceKey);//分析内存使用的结果
        AbstractAnalysisResultService.sendResultToListener(this, listenerClassName, heapDump, result);//回调进行结果的显示
      }
    }

看下heapAnalyzer.checkForLeak(heapDump.heapDumpFile, heapDump.referenceKey)方法

public AnalysisResult checkForLeak(File heapDumpFile, String referenceKey) { 
        long analysisStartNanoTime = System.nanoTime();
    
        if (!heapDumpFile.exists()) { 
          Exception exception = new IllegalArgumentException("File does not exist: " + heapDumpFile);
          return failure(exception, since(analysisStartNanoTime));
        }
    
        try { 
          HprofBuffer buffer = new MemoryMappedFileBuffer(heapDumpFile);
          HprofParser parser = new HprofParser(buffer);//解析器
          Snapshot snapshot = parser.parse();//具体的解析工作
          deduplicateGcRoots(snapshot);//去重的GCRoot,就是会对分析的结果，去除重复的内存泄漏
    
          Instance leakingRef = findLeakingReference(referenceKey, snapshot);//根据需要检测的类Key，来查询检测结果中是否我们需要的对象
    
          // False alarm, weak reference was cleared in between key check and heap dump.
          if (leakingRef == null) { //表示GC后，对象已经被清除了
            return noLeak(since(analysisStartNanoTime));
          }
    
          return findLeakTrace(analysisStartNanoTime, snapshot, leakingRef);//有泄漏，找出整个路径
        } catch (Throwable e) { 
          return failure(e, since(analysisStartNanoTime));
        }
      }

总结 checkForLeak（最重要的方法）  
1.把.hprof转化为Snapshot  
2.优化GCRoots  
3.找出泄漏的对象/找出泄漏对象的最短路径

看下findLeakingReference(referenceKey, snapshot)方法

private Instance findLeakingReference(String key, Snapshot snapshot) { 
        ClassObj refClass = snapshot.findClass(KeyedWeakReference.class.getName());//创建Class对象，通过KeyedWeakReference弱引用就可以查找出内存泄漏的对象
        List<String> keysFound = new ArrayList<>();
        for (Instance instance : refClass.getInstancesList()) { 
          List<ClassInstance.FieldValue> values = classInstanceValues(instance);
          String keyCandidate = asString(fieldValue(values, "key"));
          if (keyCandidate.equals(key)) { //找到了检测对象
            return fieldValue(values, "referent");
          }
          keysFound.add(keyCandidate);//添加找到的值
        }
        throw new IllegalStateException(
            "Could not find weak reference with key " + key + " in " + keysFound);
      }

总结findLeakingReference方法  
1.在Snapshot 快照中找到第一个弱引用（因为对象没有被回收，所以第一个对象就代表内存泄漏）  
2.遍历这个对象的所有势力  
3.如果Key值和最开始定义封装的Key值相同，那么返回这个泄漏对象

看下findLeakTrace(analysisStartNanoTime, snapshot, leakingRef)方法

private AnalysisResult findLeakTrace(long analysisStartNanoTime, Snapshot snapshot,
          Instance leakingRef) { //根据泄漏对象的引用，找到的对象，找出最短的路径
    
        ShortestPathFinder pathFinder = new ShortestPathFinder(excludedRefs);
        ShortestPathFinder.Result result = pathFinder.findPath(snapshot, leakingRef);//这两行是判断内存泄漏的关键，通过分析hprof文件，找到内存泄漏的点，判断的依据就是GCRoot,GCRoot表示不能被垃圾回收器GC回收的对象。这里我们关注两种类型，第一种静态的；第二中被其它线程所引用，并且其它线程正在运行，没有结束
    
        // False alarm, no strong reference path to GC Roots.
        if (result.leakingNode == null) { 
          return noLeak(since(analysisStartNanoTime));
        }
    
        LeakTrace leakTrace = buildLeakTrace(result.leakingNode);//生成的内存泄漏的调用栈，如果发生内存泄漏，展示在你的屏幕上的就是这个LeakTrace
    
        String className = leakingRef.getClassObj().getClassName();
    
        // Side effect: computes retained size.
        snapshot.computeDominators();
    
        Instance leakingInstance = result.leakingNode.instance;
    
        long retainedSize = leakingInstance.getTotalRetainedSize();//计算内存泄漏的空间大小
    
        // check O sources and see what happened to android.graphics.Bitmap.mBuffer
        if (SDK_INT <= N_MR1) { 
          retainedSize += computeIgnoredBitmapRetainedSize(snapshot, leakingInstance);
        }
    
        return leakDetected(result.excludingKnownLeaks, className, leakTrace, retainedSize,
            since(analysisStartNanoTime));
      }

总结findLeakTrace方法  
1.解析Hprof文件，把和这个文件封装成Snopshot  
2.根据弱引用和前面定义的Key值，确定泄漏的对象  
3.找到最短的泄漏路径，作为结果反馈出来 （如果找不到，可能是误判或者被垃圾回收器回收了）