Github地址：新闻类App （MVP + RxJava + Retrofit+Dagger+ARouter）
卡顿介绍以及优化工具选择
背景介绍：
很多性能问题不易被发现，但是卡顿很容易被直观发现，且卡顿难以定位
CPU Profiler
- 图形的形式展示执行时间，调用栈等
- 信息全面，包含所有的线程
- 缺点：运行时开销严重，整体都会变慢
- 使用方式
Debug.startMethodTracing("")
Debug.stopMethodTracing("")
生成的文件在sd卡：Android/data/packagename/files
systrace
- 监控和跟踪 API调用，线程运行情况，生成HTML报告
- API18以上使用，推荐TraceCompat
- 使用方式
python systrace.py -t 10 [other-options] [categories]
- 优点
轻量级，直观反映CPU利用率，给出建议
StrictMode
- 严苛模式，Andorid提供的一种运行时检测机制
- 方便强大，容易被忽视
- 包含：线程策略和虚拟机策略检测
线程策略
自定义耗时调用，detectCustomSlowCalls();
磁盘读取操作，detectDiskReads()
网络操作，detectNetwork
虚拟机策略
Activity泄漏，detectActivityleaks()
Sqlite对象泄漏，detectleakedSqliteObjects
检测实例数量，setClassInstanceLimit() - 代码
private boolean DEV_MODE = true;
private void initStrictMode() {
if (!DEV_MODE) {
//线程策略
StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
.detectCustomSlowCalls()//API等级11，使用StrictMode.noteSlowCode
.detectDiskReads()
.detectDiskWrites()
.detectNetwork()
.penaltyLog()//在Logcat 中打印违规异常信息
.build());
//虚拟机策略
StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
.detectLeakedSqlLiteObjects()
//模拟限制数量1
.setClassInstanceLimit(NewsTimeLine.class, 1)
.detectLeakedClosableObjects() //API等级11
.penaltyLog()
.build());
}
}
自动化卡顿检测方案及优化
理由：
- 系统工具适合线下针对行分析
- 线上及测试环境需要自动化检测方案
方案原理
- 消息处理机制，一个线程只有一个Looper
- mLogging对象在每个message处理前后被调用
- 主线程发生卡顿，是在dispatchMessage执行耗时操作
Loop源码
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
具体实现
- Looper.getMainLooper().setMessagelogging()
- 匹配>>>>> Dispatching,阈值时间后执行任务(获取堆栈)
- 匹配<<<<< Finished,任务启动之前取消掉
AndroidPerformanceMonitor
- 非侵入式的性能监控组件，通知形式弹出卡顿信息
- Github:https://github.com/markzhai/AndroidPerformanceMonitor
- 添加依赖
compile 'com.github.markzhai:blockcanary-android:1.5.0'
- 代码
App的onCreate中
BlockCanary.install(this, new AppBlockCanaryContext()).start();
AppBlockCanaryContext github中作者提供了
public class AppBlockCanaryContext extends BlockCanaryContext {
@Override
public String provideQualifier() {
return "unknown";
}
@Override
public String provideUid() {
return "uid";
}
@Override
public String provideNetworkType() {
return "unknown";
}
@Override
public int provideMonitorDuration() {
return -1;
}
@Override
public int provideBlockThreshold() {
return 500;
}
@Override
public int provideDumpInterval() {
return provideBlockThreshold();
}
@Override
public String providePath() {
return "/blockcanary/";
}
@Override
public boolean displayNotification() {
return true;
}
@Override
public boolean zip(File[] src, File dest) {
return false;
}
@Override
public void upload(File zippedFile) {
throw new UnsupportedOperationException();
}
@Override
public List<String> concernPackages() {
return null;
}
@Override
public boolean filterNonConcernStack() {
return false;
}
@Override
public List<String> provideWhiteList() {
LinkedList<String> whiteList = new LinkedList<>();
whiteList.add("org.chromium");
return whiteList;
}
@Override
public boolean deleteFilesInWhiteList() {
return true;
}
@Override
public void onBlock(Context context, BlockInfo blockInfo) {
Log.i("lz","blockInfo "+blockInfo.toString());
}
}
在fragment中添加睡眠两秒
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
结果
image.png
点击第一个
image.png
-优势：非侵入式，方便精确到哪一行
- 缺点：确实卡顿了，但卡顿堆栈可能不准确，和OOM一样，最后的堆栈只是表象，不是真正的问题
- 优化
获取监控周期内的多个堆栈，而不仅仅是最后一个
startMonitor->高频采集堆栈->endMonitior->记录多个堆栈->上报 - 海量卡顿堆栈处理
分析：一个卡顿下多个堆栈大概率有重复
解决：对一个卡顿下堆栈进行hash排查，找出重复的堆栈
效果：极大的减少展示量同时更高效的找到卡顿堆栈
ANR分析与实战
ANR产生的条件
- 1.主线程
- 2.超时时间
产生ANR的上下文不同，超时时间也会不同 - 3、输入事件/特定操作
输入事件是指按键、触屏等设备输入事件
特定操作是指BroadcastReceiver和Service的生命周期中的各个函数
ANR产生的情况
- 1、主线程对输入事件在5秒内没有处理完毕
- 2、主线程在执行BroadcastReceiver的onReceive函数时10秒内没有执行完,注意前台10s,后台60s
- 3、主线程在执行Service的各个生命周期函数时20秒内没有执行完毕,注意前台20s,后台200s
ANR执行流程
- 发生ANR
- 进程接受异常终止信号，开始写入进程ANR信息
- 弹出ANR提示框
分析ANR
ANR信息保存在在/data/anr/traces.txt中
image.png
将目录下的文件导出
Traces.txt文件分析
//文件中输出的第一个进程的trace信息，正是发生ANR的程序
//开头显示进程号、ANR发生的时间点和进程名称
----- pid 2226 at 2019-01-08 22:02:22 -----
Cmd line: com.peakmain.testproject
以下是各个线程的函数堆栈信息
image.png
//依次是：线程名、线程优先级、线程创建时的序号、线程当前状态
"main" prio=5 tid=1 Sleeping
//主线程信息
at java.lang.Thread.sleep!(Native method)
- sleeping on <0x0bf9c149> (a java.lang.Object)
at java.lang.Thread.sleep(Thread.java:371)
- locked <0x0bf9c149> (a java.lang.Object)
at java.lang.Thread.sleep(Thread.java:313)
at com.peakmain.testproject.MainActivity$2.onClick(MainActivity.java:61)
其他线程信息
image.png
ANR解决套路
- adb pull data/anr/trance.txt存储路径，可以直接导出trace文件
- 1、主线程需要做耗时操作的时候必须启动子线程处理
- 2、子线程尽量使用android提供的API，比如HandlerThread,AsyncTask
- 3、Broadcast Receiver中如果有耗时操作，可以放到service中
ANR-WatchDog
- 非侵入式的ANR监控组件
- Github:https://github.com/SalomonBrys/ANR-WatchDog
- 依赖
compile 'com.github.anrwatchdog:anrwatchdog:1.4.0'
- 代码
App的onCreate中
new ANRWatchDog().start();
- 原理
start->post消息改值->sleep->检测是否修改->判断ANR是否发生
卡顿单点问题检测方案
IPC问题检测
- IPC调用类型
- 调用耗时,次数
- 调用堆栈，发生线程
常规方案
IPC前后埋点，缺点：不够优雅，而且维护成本高
IPC问题检测技巧
- adb命令
adb shell am trace -ipc start
adb shell am trace -ipc stop ——dump-file /data/local/tmp/ipc-trace.txt
adb pull /data/local/tmp/ipc-trace.txt
优雅的方案:ARTHook
- 挂钩，将额外的代码钩住原有的方法，修改执行逻辑
- 框架：Epic(不能带到线上环境)
try {
DexposedBridge.findAndHookMethod(Class.forName("android.os.BinderProxy"), "transact",
int.class, Parcel.class, Parcel.class, int.class, new XC_MethodHook() {
@Override
protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
LogUtils.i( "BinderProxy beforeHookedMethod " + param.thisObject.getClass().getSimpleName()
+ "\n" + Log.getStackTraceString(new Throwable()));
super.beforeHookedMethod(param);
}
});
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
实现界面秒开
- onCreate到onWindowFocusChanged消耗的时间
Lancet
- 编译速度快，支持增量更新
- API简单，没有任何多余代码插入apk
- Github:https://github.com/eleme/lancet
- API介绍
@Proxy通常用于对系统API调用的Hook
@Insert通常用于操作App与libray的类 - 依赖
classpath 'me.ele:lancet-plugin:1.0.4'
apply plugin: 'me.ele.lancet'
dependencies {
provided 'me.ele:lancet-base:1.0.4'
}
- 代码
public class ActivityHooker {
public static ActivityRecord sActivityRecord;
static {
sActivityRecord=new ActivityRecord();
}
@Insert(value = "onCreate",mayCreateSuper = true)
@TargetClass(value = "android.support.v7.app.AppCompatActivity",scope = Scope.ALL)
protected void onCreate(Bundle savedInstanceState) {
sActivityRecord.mOnCreateTime = System.currentTimeMillis();
Origin.callVoid();
}
@Insert(value = "onWindowFocusChanged",mayCreateSuper = true)
@TargetClass(value = "android.support.v7.app.AppCompatActivity",scope = Scope.ALL)
public void onWindowFocusChanged(boolean hasFocus) {
sActivityRecord.mOnWindowsFocusChangedTime = System.currentTimeMillis();
Log.i("ActivityHooker","onWindowFocusChanged cost "+(sActivityRecord.mOnWindowsFocusChangedTime - sActivityRecord.mOnCreateTime));
Origin.callVoid();
}
/**
* hook系统方法
*/
@Proxy("i")
@TargetClass("android.util.Log")
public static int i(String tag, String msg) {
msg = msg + "ActivityHooker";
return (int) Origin.call();
}
}
监控耗时盲区
背景：
- 生命周期的间隔
- onResume到feed(界面数据)展示的间隔
- 举例：postmessage，很可能在feed之前显示
- 线下方案:tranceView
- 线上方案
1.主线程所有方法都经过msg,但是没有msg具体堆栈
2.使用统一的Handler:定制具体的方法,发送消息都会走到sendMessageAtTime和处理消息都会走到dispatchMessage方法
public class PeakmainHandler extends Handler {
private long mStartTime = System.currentTimeMillis();
private ConcurrentHashMap<Message, String> sMsgDetail = new ConcurrentHashMap<>();
public PeakmainHandler() {
super(Looper.myLooper(), null);
}
public PeakmainHandler(Callback callback) {
super(Looper.myLooper(), callback);
}
public PeakmainHandler(Looper looper, Callback callback) {
super(looper, callback);
}
public PeakmainHandler(Looper looper) {
super(looper);
}
@Override
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
boolean send = super.sendMessageAtTime(msg, uptimeMillis);
if (send) {
sMsgDetail.put(msg, Log.getStackTraceString(new Throwable()).replace("java.lang.Throwable", ""));
}
return send;
}
@Override
public void dispatchMessage(Message msg) {
mStartTime = System.currentTimeMillis();
super.dispatchMessage(msg);
if (sMsgDetail.containsKey(msg)
&& Looper.myLooper() == Looper.getMainLooper()) {
JSONObject jsonObject = new JSONObject();
try {
jsonObject.put("Msg_Cost", System.currentTimeMillis() - mStartTime);
jsonObject.put("MsgTrace", msg.getTarget() + " " + sMsgDetail.get(msg));
Log.i("PeakmainHandler", "MsgDetail " + jsonObject.toString());
sMsgDetail.remove(msg);
} catch (Exception e) {
}
}
}
}
- 3.gradle定制，编译时动态替换Handler，这里我并没有去做gradle插件(理由：懒)，只说下我的代码实现，这里我多写了个方法，获取所有的Handler
写个类HandlerHelper,随后在App中初始化就可以了
public class HandlerHelper {
public static void init() {
try {
//获取系统的Handler的sendMessageAtTime
Class<?> handlerClass = Class.forName("android.os.Handler");
Method sendMessageAtTime = handlerClass.getDeclaredMethod("sendMessageAtTime", new Class[]{Message.class, long.class});
PeakmainHandler peakmainHandler=new PeakmainHandler();
handlerClass=peakmainHandler.getClass();
Object obj = Proxy.newProxyInstance(handlerClass.getClassLoader(), handlerClass.getInterfaces(), new HandlerProxy(handlerClass));
sendMessageAtTime.invoke(handlerClass,obj);
} catch (Exception e) {
e.printStackTrace();
}
}
private static class HandlerProxy implements InvocationHandler {
private Class<?> mHandlerClass;
public HandlerProxy(Class<?> handlerClass) {
this.mHandlerClass=handlerClass;
}
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
return method.invoke(mHandlerClass,objects);
}
}
public static List<Handler> getHandlerByApplication(Application application) {
List<Handler> list = new ArrayList<>();
try {
Class<Application> applicationClass = Application.class;
Field mLoadedApkField = applicationClass.getDeclaredField("mLoadedApk");
mLoadedApkField.setAccessible(true);
Object mLoadedApk = mLoadedApkField.get(application);
Class<?> mLoadedApkClass = mLoadedApk.getClass();
Field mActivityThreadField = mLoadedApkClass.getDeclaredField("mActivityThread");
mActivityThreadField.setAccessible(true);
Object mActivityThread = mActivityThreadField.get(mLoadedApk);
Class<?> mActivityThreadClass = mActivityThread.getClass();
Field mActivitiesField = mActivityThreadClass.getDeclaredField("mH");
mActivitiesField.setAccessible(true);
Object mH = mActivitiesField.get(mActivityThread);
// 注意这里一定写成Map，低版本这里用的是HashMap，高版本用的是ArrayMap
list.add((Handler) mH);
} catch (Exception e) {
e.printStackTrace();
list = null;
}
return list;
}
}
使用
new PeakmainHandler().post(new Runnable() {
@Override
public void run() {
LogUtils.e("开始了");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
