新闻类App （MVP + RxJava + Retrofit+Dagger+ARouter）性能优化之APP卡顿优化

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 concernPackages() {
        return null;
    }


    @Override
    public boolean filterNonConcernStack() {
        return false;
    }


    @Override
    public List provideWhiteList() {
        LinkedList 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();
        }

结果

新闻类App （MVP + RxJava + Retrofit+Dagger+ARouter）性能优化之APP卡顿优化_第1张图片

image.png

点击第一个

新闻类App （MVP + RxJava + Retrofit+Dagger+ARouter）性能优化之APP卡顿优化_第2张图片

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中

新闻类App （MVP + RxJava + Retrofit+Dagger+ARouter）性能优化之APP卡顿优化_第3张图片

image.png

将目录下的文件导出

Traces.txt文件分析

//文件中输出的第一个进程的trace信息，正是发生ANR的程序
//开头显示进程号、ANR发生的时间点和进程名称
----- pid 2226 at 2019-01-08 22:02:22 -----
Cmd line: com.peakmain.testproject

以下是各个线程的函数堆栈信息

新闻类App （MVP + RxJava + Retrofit+Dagger+ARouter）性能优化之APP卡顿优化_第4张图片

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)

其他线程信息

新闻类App （MVP + RxJava + Retrofit+Dagger+ARouter）性能优化之APP卡顿优化_第5张图片

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 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 getHandlerByApplication(Application application) {
        List list = new ArrayList<>();
        try {
            Class 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();
                }
            }
        });

新闻类App （MVP + RxJava + Retrofit+Dagger+ARouter）性能优化之APP卡顿优化

卡顿介绍以及优化工具选择

自动化卡顿检测方案及优化

ANR分析与实战

卡顿单点问题检测方案

实现界面秒开

监控耗时盲区

你可能感兴趣的:(新闻类App （MVP + RxJava + Retrofit+Dagger+ARouter）性能优化之APP卡顿优化)