需要清楚 ANR 的概念、类型、如何产生以及如何定位分析。
1、概述
1.1 ANR 的概念
ANR（Application Not Responding）应用程序无响应。如果你应用程序在主线程被阻塞太长时间，就会出现 ANR，通常出现 ANR，系统会弹出一个提示框，让用户知道，该程序正在被阻塞，是否继续等待还是关闭。
1.2 ANR 类型
ANR 有 4 种类型：
- KeyDispatchTimeout（常见）：Input 事件在 5 秒内没有处理完成导致发生 ANR
- logcat 日志关键字：Input event dispatching timed out
- BroadcastTimeout：前台 BroadcastReceiver 的 onReceive() 在 10 秒内没有处理完成、后台 BroadcastReceiver 的 onReceive() 在 60 秒内没有处理完成会发生 ANR
- logcat 日志关键字：Timeout of broadcast BroadcastRecord
- ServiceTimeout：前台 Service 的 onCreate、onStart、onBind 等生命周期方法在 20 秒内没有处理完成，后台 Service 的onCreate、onStart、onBind 等生命周期方法在 200 秒内没有处理完成会发生 ANR
- logcat 日志关键字：Timeout executing service
- ContentProviderTimeout：ContentProvider 在 10 秒内没有处理完成发生 ANR。
- logcat日志关键字：timeout publishing content providers
注意，KeyDispatchTimeout 与其他机制不同。对于 Input 来说，即便某次事件的执行时间超过 5 秒，只要用户后续没有再生成新的 Input 事件，就不会触发 ANR。
1.3 ANR 出现的原因
原因主要有以下几种：
- 主线程频繁进行耗时的 IO 操作：如数据库读写
- 多线程操作的死锁，主线程被 block
- 主线程被 Binder 对端 block
- System Server 中 WatchDog 出现 ANR
- Service binder 的连接达到上限无法和 System Server 通信
- 系统资源已耗尽（管道、CPU、IO）
凡是进行 IO 读写的操作，都不要放在主线程中，SharedPreferences 也涉及 IO 操作，也包含在内。此外，网络、序列化也不要放在主线程中。
多核 CPU 的执行效率不一样，以八核为例，一般 0~3 是小核，4~5 是中核，6~7 是大核，手机厂商在游戏模式中会将游戏绑定到大核上运行。
2、ANR 问题的解决
线下的 ANR 问题，有 3 个 log 文件可以寻找相关信息：
- /data/anr/trace_*.txt：一般 firstPid 就是发生 ANR 的 pid。主要是在 ActivityManagerservice 中通过 appNotResponding()、dumpStackTraces() 来生成应用的 ANR
- traces_SystemServer_WDT.txt：WatchDog 中实现，会打印 system_server 进程栈信息
- traces.txt：dalvik.vm.stack-trace-file，是系统定义的默认 trace 文件路径
线上的 ANR 问题，一般只能通过 Bugly 提供信息，而且信息还有可能不全，因此线上 ANR 是很不好解决的。
2.1 分析技巧
ANR 问题除了特别明显的那种，一般都不是一眼就能看出来问题点的，需要多个角度分析。
分析技巧主要有以下几点：
- 通过 logcat 日志，traces 文件确认 ANR 发生时间点
- traces 文件和 CPU 使用率
- /data/anr/traces.txt
- 主线程状态
- 其他线程状态
2.2 关键信息
关键信息1：
ANR时间：07-20 15:36:36.472
进程pid：1480
进程名：com.xxxx.moblie
ANR类型：KeyDispatchTimeout
关键信息2：
main：main标识是主线程，如果是线程，那么命名成“Thread-X”的格式,x表示线程id,逐步递增。
prio：线程优先级,默认是5
tid：tid不是线程的id，是线程唯一标识ID
group：是线程组名称
sCount：该线程被挂起的次数
dsCount：是线程被调试器挂起的次数
obj：对象地址
self：该线程Native的地址
sysTid：是线程号(主线程的线程号和进程号相同)
nice：是线程的调度优先级
sched：分别标志了线程的调度策略和优先级
cgrp：调度归属组
handle：线程处理函数的地址。
state：是调度状态
schedstat：从 /proc/[pid]/task/[tid]/schedstat读出，三个值分别表示线程在cpu上执行的时间、线程的等待时间和线程执行的时间片长度，不支持这项信息的三个值都是0；
utm：是线程用户态下使用的时间值(单位是jiffies）
stm：是内核态下的调度时间值
core：是最后执行这个线程的cpu核的序号
线程状态：
THREAD_UNDEFINED = -1
THREAD_ZOMBIE = 0, /* TERMINATED /
THREAD_RUNNING = 1, / RUNNABLE or running now /
THREAD_TIMED_WAIT = 2,/ TIMED_WAITING Object.wait()
THREAD_MONITOR = 3, /* BLOCKED on a monitor /
THREAD_WAIT = 4, / WAITING in Object.wait() /
THREAD_INITIALIZING= 5, / allocated, not yet running /
THREAD_STARTING = 6, / started, not yet on thread list /
THREAD_NATIVE = 7, / off in a JNI native method /
THREAD_VMWAIT = 8, / waiting on a VM resource /
THREAD_SUSPENDED = 9, / suspended, usually by GC or debugger
3、ANR 线上监控方案
两种方案，原生的可以通过 FileObserver，也可以通过 WatchDog。
3.1 FileObserver
FileObserver 可以监控某个目录/文件的状态发生改变、创建或删除文件，可以监听 /data/anr/ 目录下的文件变化。这样在发生变化时可以上传所有 ANR 的信息到服务器上，但是有可能是其他应用发生的 ANR。示例代码：
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;
}
}
}
FileObserver 在 5.0 的系统以上会受到 SELinux 的限制，手机厂商可以通过修改 .te 的配置文件规避掉这个限制。
3.2 WatchDog
WatchDog 是一个单例线程，在 Android 中主要用来检查 system_server 进程有没有死锁，或者某些线程有没有被卡住。其内部类 HandlerChecker 把自己加到 Handler 中：
public final class HandlerChecker implements Runnable {
private final Handler mHandler;
public void scheduleCheckLocked() {
if (mMonitors.size() == 0 && mHandler.getLooper().getQueue().isPolling()) {
mCompleted = true;
return;
}
if (!mCompleted) {
// we already have a check in flight, so no need
return;
}
mCompleted = false;
mCurrentMonitor = null;
mStartTime = SystemClock.uptimeMillis();
// 将自己加入到 Handler 中
mHandler.postAtFrontOfQueue(this);
}
@Override
public void run() {
final int size = mMonitors.size();
for (int i = 0 ; i < size ; i++) {
synchronized (Watchdog.this) {
mCurrentMonitor = mMonitors.get(i);
}
mCurrentMonitor.monitor();
}
synchronized (Watchdog.this) {
mCompleted = true;
mCurrentMonitor = null;
}
}
}
WatchDog 会持续运行，检查 HandlerChecker 中的 run() 有没有被执行：
@Override
public void run() {
boolean waitedHalf = false;
while (true) {
final List<HandlerChecker> blockedCheckers;
final String subject;
final boolean allowRestart;
int debuggerWasConnected = 0;
synchronized (this) {
long timeout = CHECK_INTERVAL;
// Make sure we (re)spin the checkers that have become idle within
// this wait-and-check interval
for (int i=0; i<mHandlerCheckers.size(); i++) {
HandlerChecker hc = mHandlerCheckers.get(i);
hc.scheduleCheckLocked();
}
if (debuggerWasConnected > 0) {
debuggerWasConnected--;
}
long start = SystemClock.uptimeMillis();
while (timeout > 0) {
if (Debug.isDebuggerConnected()) {
debuggerWasConnected = 2;
}
try {
wait(timeout);
} catch (InterruptedException e) {
Log.wtf(TAG, e);
}
if (Debug.isDebuggerConnected()) {
debuggerWasConnected = 2;
}
timeout = CHECK_INTERVAL - (SystemClock.uptimeMillis() - start);
}
boolean fdLimitTriggered = false;
if (mOpenFdMonitor != null) {
fdLimitTriggered = mOpenFdMonitor.monitor();
}
if (!fdLimitTriggered) {
final int waitState = evaluateCheckerCompletionLocked();
if (waitState == COMPLETED) {
// The monitors have returned; reset
waitedHalf = false;
continue;
} else if (waitState == WAITING) {
// still waiting but within their configured intervals; back off and recheck
continue;
} else if (waitState == WAITED_HALF) {
if (!waitedHalf) {
// We've waited half the deadlock-detection interval. Pull a stack
// trace and wait another half.
ArrayList<Integer> pids = new ArrayList<Integer>();
pids.add(Process.myPid());
// 如果任务没执行，生成 trace 文件
ActivityManagerService.dumpStackTraces(true, pids, null, null,
getInterestingNativePids());
waitedHalf = true;
}
continue;
}
// something is overdue!
blockedCheckers = getBlockedCheckersLocked();
subject = describeCheckersLocked(blockedCheckers);
} else {
blockedCheckers = Collections.emptyList();
subject = "Open FD high water mark reached";
}
allowRestart = mAllowRestart;
...
}
}
}
我们可以借鉴 WatchDog 的原理自己检测：
代码如下：
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();
}
}
WatchDog 会有性能损耗。