Android性能优化--ANR问题

奋斗的小鹰

已于 2024-02-21 17:21:27 修改

阅读量748

点赞数

文章标签： android 性能优化

于 2023-04-21 16:05:06 首次发布

本文链接：https://blog.csdn.net/qq_27246079/article/details/130265524

版权

一、ANR有哪些类型（Application No Responding）

1. KeyDispatchTimeout （常见）

input事件在5s内没处理完产生ANR

logcat日志关键字：Input event dispatching timed out

注：input的超时机制与其他的不同，对于input来说即便某次事件超过限时，只要用户后续没有后续输入，则不会产生ANR问题。

2.BroadcastTimeout

前台广播：onReceiver在10s内没处理完导致ANR。

后台广播：onReceiver在60s内没处理完导致ANR

logcat日志关键字：Timeout of broadcast BroadcastRecord

3.ServiceTimeout

前台service：onCreate(),onStart(),onBind()等生命周期方法在20s内没处理完导致ANR。

后台service：onCreate(),onStart(),onBind()等生命周期方法在200s内没处理完导致ANR。

logcat日志关键字：Timeout excuting service

4.ContentProviderTimeout

ContentProvider 在10s内没有处理完导致ANR

logcat日志关键字：timeout publishing content providers

二、出现ANR的场景

主线程频繁的进行耗时的io操作，如读写数据库
多线程的死锁，主线程被block （traces文件中搜索 held by）
主线程被 Binder对端block
System Server中WatchDog出现ANR
service binder的连接达到上限，无法和systemserver通信
系统资源已耗尽（管道、cpu、io）

三、ANR问题如何解决

traces_*.txt

*一般是firstPid，即发生ANR的pid

ActivityManagerService中实现，通过appNotResponding(),dumpStackTraces()两个主要方法来生成应用的anr。

traces_SystemServer_WDT.txt

Watchdog中实现

system_server进程栈信息

traces.txt

系统定义的默认trace文件路径

线下：可查看本地的日志文件进行分析

ANR日志路径：/data/anr/ ，若看不到此路径，可以在命令行输入：adb bugreport来导出日志

通过logcat日志，traces文件确认：

anr发生的时间点

cpu的使用率

主线程的状态

其他线程的状态

线上：

1.集成bugly，可以拿到手机品牌，型号，配置，以及anr的大概位置

2.自己实现anr的监控方案

四、线上监控方案

1.FileObserver实现

注：5.0之上会被selinux限制访问，厂商的话可以修改.te文件

package com.xiangxue.arch_demo.anr;

import android.os.FileObserver;
import android.util.Log;

import androidx.annotation.Nullable;

public class ANRFileObserver extends FileObserver {


    public ANRFileObserver(String path) {//data/anr/
        super(path);
    }

    public ANRFileObserver(String path, int mask) {
        super(path, mask);
    }

    @Override
        public void onEvent(int event, @Nullable String path) {
            switch (event)
        {
            case FileObserver.ACCESS://文件被访问
                Log.i("Zero", "ACCESS: " + path);
                break;
            case FileObserver.ATTRIB://文件属性被修改，如 chmod、chown、touch 等
                Log.i("Zero", "ATTRIB: " + path);
                break;
            case FileObserver.CLOSE_NOWRITE://不可写文件被 close
                Log.i("Zero", "CLOSE_NOWRITE: " + path);
                break;
            case FileObserver.CLOSE_WRITE://可写文件被 close
                Log.i("Zero", "CLOSE_WRITE: " + path);
                break;
            case FileObserver.CREATE://创建新文件
                Log.i("Zero", "CREATE: " + path);
                break;
            case FileObserver.DELETE:// 文件被删除，如 rm
                Log.i("Zero", "DELETE: " + path);
                break;
            case FileObserver.DELETE_SELF:// 自删除，即一个可执行文件在执行时删除自己
                Log.i("Zero", "DELETE_SELF: " + path);
                break;
            case FileObserver.MODIFY://文件被修改
                Log.i("Zero", "MODIFY: " + path);
                break;
            case FileObserver.MOVE_SELF://自移动，即一个可执行文件在执行时移动自己
                Log.i("Zero", "MOVE_SELF: " + path);
                break;
            case FileObserver.MOVED_FROM://文件被移走，如 mv
                Log.i("Zero", "MOVED_FROM: " + path);
                break;
            case FileObserver.MOVED_TO://文件被移来，如 mv、cp
                Log.i("Zero", "MOVED_TO: " + path);
                break;
            case FileObserver.OPEN://文件被 open
                Log.i("Zero", "OPEN: " + path);
                break;
            default:
                //CLOSE ： 文件被关闭，等同于(IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
                //ALL_EVENTS ： 包括上面的所有事件
                Log.i("Zero", "DEFAULT(" + event + "): " + path);
                break;
        }
    }
}

2.watchdog实现

import android.annotation.TargetApi;
import android.os.Build;
import android.os.Debug;
import android.os.Handler;
import android.os.Looper;
import android.os.Process;
import android.os.SystemClock;
import android.util.Log;


public class ANRWatchDog extends Thread {

    private static final String TAG = "ANR";
    private int timeout = 5000;
    private boolean ignoreDebugger = true;

    static ANRWatchDog sWatchdog;

    private Handler mainHandler = new Handler(Looper.getMainLooper());


    private class ANRChecker implements Runnable {

        private boolean mCompleted;
        private long mStartTime;
        private long executeTime = SystemClock.uptimeMillis();

        @Override
        public void run() {
            synchronized (ANRWatchDog.this) {
                mCompleted = true;
                executeTime = SystemClock.uptimeMillis();
            }
        }

        void schedule() {
            mCompleted = false;
            mStartTime = SystemClock.uptimeMillis();
            mainHandler.postAtFrontOfQueue(this);
        }

        boolean isBlocked() {
            return !mCompleted || executeTime - mStartTime >= 5000;
        }
    }

    public interface ANRListener {
        void onAnrHappened(String stackTraceInfo);
    }

    private ANRChecker anrChecker = new ANRChecker();

    private ANRListener anrListener;

    public void addANRListener(ANRListener listener){
        this.anrListener = listener;
    }

    public static ANRWatchDog getInstance(){
        if(sWatchdog == null){
            sWatchdog = new ANRWatchDog();
        }
        return sWatchdog;
    }

    private ANRWatchDog(){
        super("ANR-WatchDog-Thread");
    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
    @Override
    public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); // 设置为后台线程
        while(true){
            while (!isInterrupted()) {
                synchronized (this) {
                    anrChecker.schedule();
                    long waitTime = timeout;
                    long start = SystemClock.uptimeMillis();
                    while (waitTime > 0) {
                        try {
                            wait(waitTime);
                        } catch (InterruptedException e) {
                            Log.w(TAG, e.toString());
                        }
                        waitTime = timeout - (SystemClock.uptimeMillis() - start);
                    }
                    if (!anrChecker.isBlocked()) {
                        continue;
                    }
                }
                if (!ignoreDebugger && Debug.isDebuggerConnected()) {
                    continue;
                }
                String stackTraceInfo = getStackTraceInfo();
                if (anrListener != null) {
                    anrListener.onAnrHappened(stackTraceInfo);
                }
            }
            anrListener = null;
        }
    }

    private String getStackTraceInfo() {
        StringBuilder stringBuilder = new StringBuilder();
        for (StackTraceElement stackTraceElement : Looper.getMainLooper().getThread().getStackTrace()) {
            stringBuilder
                    .append(stackTraceElement.toString())
                    .append("\r\n");
        }
        return stringBuilder.toString();
    }
}

使用：

ANRWatchDog.getInstance().addANRListener({
   @Override
   public void onAnrHappend(String stackTraceInfo){
   }
});

ANRWatchDog.getInstance().start();