Koom流程记录(一)

https://github.com/KwaiAppTeam/KOOM

class KOOMInternal implements HeapDumpListener, HeapAnalysisListener {
    
    //handle.post 来控制执行时机,10s 之后执行
    private void startInternal() {
        //...
        if (KOOMEnableChecker.doCheck() != KOOMEnableChecker.Result.NORMAL) {
            KLog.e(TAG, "koom start failed, check result: " + KOOMEnableChecker.doCheck());
            return;
        }
        //1.如果之前崩溃过 ,本地有hporf文件直接分析
        ReanalysisChecker reanalysisChecker = new ReanalysisChecker();
        //本地KHeapFile 存在,直接再分析一次 ,否则开启监控
        if (reanalysisChecker.detectReanalysisFile() != null) {
            KLog.i(TAG, "detected reanalysis file");
            heapAnalysisTrigger
                    .trigger(TriggerReason.analysisReason(TriggerReason.AnalysisReason.REANALYSIS));
            return;
        }
        //2.否则再开启一个HandlerThread作为监控线程, 开始监控内存变化
        // 直接调度MonitorManager
        heapDumpTrigger.startTrack();
    }
}

public class KConstants {
    
    public static float getDefaultPercentRation() {
      //获取最大可用内存
      int maxMem = (int) (Runtime.getRuntime().maxMemory() / MB);
      if (Debug.VERBOSE_LOG) {
        KLog.i("koom", "max mem " + maxMem);
      }
      // 512 MB 的设备 阈值百分比是80
      if (maxMem >= VM_512_DEVICE) {
        return HeapThreshold.PERCENT_RATIO_IN_512_DEVICE;
      } else if (maxMem >= VM_256_DEVICE) {
        //256MB 的设备 阈值百分比是85
        return HeapThreshold.PERCENT_RATIO_IN_256_DEVICE;
      } else if (maxMem >= VM_128_DEVICE) {
        //128MB的设备 阈值百分比是90
        return HeapThreshold.PERCENT_RATIO_IN_128_DEVICE;
      }
      // 其他 阈值百分比一律为80
      return HeapThreshold.PERCENT_RATIO_IN_512_DEVICE;
    }
}

public class MonitorManager {
   
  public void start() {
    //monitors集合只有一个HeapMonitor对象
    monitorThread.start(monitors);
  } 
}

public class MonitorThread {
    
    public void start(List<Monitor> monitors) {
        //...
        List<Runnable> runnables = new ArrayList<>();
        for (Monitor monitor : monitors) {
            //获取HeapMonitor的heapThreshold
            monitor.start();
            runnables.add(new MonitorRunnable(monitor));
        }
        //执行 list 中的Runnable,因为只有一个,就是MonitorRunnable了
        for (Runnable runnable : runnables) {
            // 使用handler 发送MonitorRunnable, 结果就是执行MonitorRunnable其 run()方法
            handler.post(runnable);
        }
    }
    //
    class MonitorRunnable implements Runnable {
        //...
        @Override
        public void run() {
            // if 分支为 true 说明 APP 占用内存使用超过阈值 3 次
            if (monitor.isTrigger()) {
                // 这里 stop 恒为 true
                stop = monitorTriggerListener
                        .onTrigger(monitor.monitorType(), monitor.getTriggerReason());
            }
            // 上面的 if 分支不被执行 ,stop一直为 false
            // 那么当前run()方法,每隔 5s 就会执行一次 形成一个循环
            if (!stop) {
                handler.postDelayed(this, monitor.pollInterval());
            }
        }
    }
}

public class HeapThreshold implements Threshold {
  //根据不同的手机的最大内存,返回不同的值
  private float heapRatioInPercent;
  //默认 3 超过这个次数 开始内存分析
  private int overTimes;
  // HeapMonitor检测的频率 默认 5s
  private int pollInterval;
}

public class HeapDumpTrigger implements KTrigger {
 
   @Override
   public void trigger(TriggerReason reason) {
 
     if (heapDumpListener != null) {
       // 对外回调回调进度 Progress.HEAP_DUMP_START
       heapDumpListener.onHeapDumpTrigger(reason.dumpReason);
     }
 
     // 分析HeapDump
     doHeapDump(reason.dumpReason);
   }
   //
  public void doHeapDump(TriggerReason.DumpReason reason) {
    // 构建KHeapFile
    KHeapFile.getKHeapFile().buildFiles();

    HeapAnalyzeReporter.addDumpReason(reason);
    // 收集设备信息
    HeapAnalyzeReporter.addDeviceRunningInfo();
    
    // 关键 代码
    boolean res = heapDumper.dump(KHeapFile.getKHeapFile().hprof.path);

    if (res) {
      //对外回调回调进度 Progress.HEAP_DUMPED
      heapDumpListener.onHeapDumped(reason);
    } else {
      KLog.e(TAG, "heap dump failed!");
      //对外回调回调进度 Progress.HEAP_DUMP_FAILED
      heapDumpListener.onHeapDumpFailed();
      KHeapFile.delete();
    }
  }
}

public class ForkJvmHeapDumper implements HeapDumper {
   @Override
   public boolean dump(String path) {
     //...
     try {
       int pid = trySuspendVMThenFork();
       if (pid == 0) {
        //...
       } else {
         resumeVM();
         // 关键代码
         dumpRes = waitDumping(pid);
       }
 
     } catch (Exception e) {
     }
     return dumpRes;
   }   
}

{
	"runningInfo": {
		"analysisReason": "RIGHT_NOW",
		"appVersion": "1.0",
		"buildModel": "iPhone12 Pro",
		"currentPage": "MainActivity",
		"dumpReason": "HEAP_OVER_THRESHOLD",
		"jvmMax": 256,
		"jvmUsed": 192,
		"koomVersion": 1,
		"manufacture": "iPhone12Mobile",
		"nowTime": "2020-08-25_22-04-35",
		"pss": 200,
		"rss": 282,
		"sdkInt": 23,
		"threadCount": 31,
		"usageSeconds": 37,
		"vss": 1966
	}
}

public class MyApplication extends Application {
    
    @Override
    public void onCreate() {
        super.onCreate();
        KOOM.init(this);
        //增加配置,方便看结果
        KOOM.getInstance().setKConfig(new KConfig.KConfigBuilder().heapRatio(30f).heapOverTimes(2).build());
    }
}