Android ANR原理分析

目录
  • 卡顿原理
  • 卡顿监控
  • ANR原理

卡顿原理

主线程有耗时操作会导致卡顿,卡顿超过阀值,触发ANR。 应用进程启动时候,Zygote会反射调用ActivityThread的main方法,启动loop循环。 ActivityThread(api29)

    public static void main(String[] args) {
        Looper.prepareMainLooper();
        ...
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

Looper的loop方法:

// 在线程中运行消息队列。一定要调用
public static void loop() {
        for (;;) {
            // 1、取消息
            Message msg = queue.next(); // might block
            ...
            // This must be in a local variable, in case a UI event sets the logger
            // 2、消息处理前回调
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }
            ...
            // 3、消息开始处理
            msg.target.dispatchMessage(msg);
            ...
            // 4、消息处理完回调
            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }
        }
}

loop中for循环存在,主线程可以长时间运行。在主线程执行任务,可以通过Handler post一个任务到消息队列去,loop循环拿到msg,交给msg的target(Handler)处理。

可能导致卡顿两个地方:

  • 注释1 queue.next()
  • 注释3 dispatchMessage耗时

MessageQueue.next 耗时代码(api29)

    @UnsupportedAppUsage
    Message next() {
        for (;;) {
            // 1、nextPollTimeoutMillis不为0则阻塞
            nativePollOnce(ptr, nextPollTimeoutMillis);
            // 2、先判断当前第一条消息是不是同步屏障消息,
            if (msg != null && msg.target == null) {
                    // 3、遇到同步屏障消息,就跳过去取后面的异步消息来处理,同步消息相当于被设立了屏障
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
             }
             // 4、正常消息处理,判断是否延时
             if (msg != null) {
                    if (now < msg.when) {
                        // Next message is not ready.  Set a timeout to wake up when it is ready.
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // Got a message.
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    // 5、如果没有取到异步消息,下次循环到注视1,nativePollOnce为-1,会一直阻塞
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }
        }
    }
  1. MessageQueue是链表数据结构,判断MessageQueue头部(第一个消息)是不是同步屏障消息(给同步消息加一层屏障,让同步消息不被处理,只会处理异步消息);
  2. 如果遇到同步屏障消息,就会跳过MessageQueue中同步消息,只会处理里面的异步消息来处理。如果没有异步消息则到注释5,nextPollTimeoutMillis为-1,下次循环调用注释1的nativePollOnce就会阻塞;
  3. 如果looper能正常获取消息,不论异步/同步消息,处理流程一样,在注释4,判断是否延时,如果是,nextPollTimeoutMillis被赋值,下次调用注释1的nativePollOnce就会阻塞一段时间。如果不是delay消息,直接返回msg,给handler处理。

next方法不断从MessageQueue取消息,有消息就处理,没有消息就调用nativePollOnce阻塞,底层是Linux的epoll机制,Linux IO多路复用。

Linux IO多路复用方案有select、poll、epoll。其中epoll性能最优,支持并发量最大。

  • select: 是操作系统提供的系统调用函数,可以把文件描述符的数组发给操作系统,操作系统去遍历,确定哪个描述符可以读写,告诉我们去处理。
  • poll:和select主要区别,去掉了select只能监听1024个文件描述符的限制。
  • epoll:针对select的三个可优化点进行改进。
1、内核中保持一份文件描述符集合,无需用户每次重新传入,只需要告诉内核修改部分。
2、内核不再通过轮询方式找到就绪的文件描述符,通过异步IO事件唤醒。
3、内核仅会将有IO的文件描述符返回给用户,用户无需遍历整个文件描述符集合。

同步屏障消息

Android App是无法直接调用同步消息屏障的,MessageQueue(api29)代码

    @TestApi
    public int postSyncBarrier() {
        return postSyncBarrier(SystemClock.uptimeMillis());
    }

    private int postSyncBarrier(long when) {
        ...
    }

系统高优先级的操作使用到同步屏障消息,例如:View绘制的时候ViewRootImpl的scheduleTraversals方法,插入同步屏障消息,绘制完成后移除同步屏障消息。ViewRootImpl api29

    @UnsupportedAppUsage
    void scheduleTraversals() {
        if (!mTraversalScheduled) {
            mTraversalScheduled = true;
            mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();
            mChoreographer.postCallback(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
            if (!mUnbufferedInputDispatch) {
                scheduleConsumeBatchedInput();
            }
            notifyRendererOfFramePending();
            pokeDrawLockIfNeeded();
        }
    }

    void unscheduleTraversals() {
        if (mTraversalScheduled) {
            mTraversalScheduled = false;
            mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);
            mChoreographer.removeCallbacks(
                    Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        }
    }

为了保证View的绘制过程不被主线程其他任务影响,View在绘制之前会先往MessageQueue插入同步屏障消息,然后再注册Vsync信号监听,Choreographer$FrameDisplayEventReceiver监听接收vsync信号回调的。

private final class FrameDisplayEventReceiver extends DisplayEventReceiver
            implements Runnable {
            @Override
            public void onVsync(long timestampNanos, long physicalDisplayId, int frame) {
                Message msg = Message.obtain(mHandler, this);
                // 1、发送异步消息
                msg.setAsynchronous(true);
                mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
              }

                      @Override
            public void run() {
                // 2、doFrame优先执行
                doFrame(mTimestampNanos, mFrame);
              }
            }

收到Vsync信号回调,注释1往主线程MessageQueue post一个异步消息,保证注释2的doFrame优先执行。

doFrame才是View真正开始绘制的地方,会调用ViewRootIml的doTraversal、performTraversals,而performTraversals里面会调用View的onMeasure、onLayout、onDraw。

虽然app无法发送同步屏障消息,但是使用异步消息是允许的。

异步消息 SDK中限制了App不能post异步消息到MessageQueue中,Message类

    @UnsupportedAppUsage
    /*package*/ int flags;

谨慎使用异步消息,使用不当,可能出现主线程假死。

Handler#dispatchMessage

    /**
     * Handle system messages here.
     */
    public void dispatchMessage(@NonNull Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }
  1. Handler#post(Runnable r)
  2. 构造方法传CallBack
  3. Handler重写handlerMessage方法

应用卡顿,一般都是Handler处理消息太耗时导致的(方法本身、算法效率、cpu被抢占、内存不足、IPC超时等)

卡顿监控

卡顿监控方案一 Looper#loop

// 在线程中运行消息队列。一定要调用
public static void loop() {
        for (;;) {
            // 1、取消息
            Message msg = queue.next(); // might block
            ...
            // This must be in a local variable, in case a UI event sets the logger
            // 2、消息处理前回调
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }
            ...
            // 3、消息开始处理
            msg.target.dispatchMessage(msg);
            ...
            // 4、消息处理完回调
            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }
        }
}

注释2和4的logging.println是api提供接口,可监听Handler耗时,通过Looper.getMainLooper().setMessageLogging(printer),拿到消息前后的时间。监听到卡顿后,dispatchMessage早已调用结束,堆栈不包含卡顿代码。

定时获取主线程堆栈,时间为key,堆栈信息为value,保存map中,发生卡顿,取出卡顿时间内的堆栈可行。适合线下使用。

  1. logging.println存在字符串拼接,频繁调用,创建大量对象,内存抖动。
  2. 后台频繁获取主线程堆栈,对性能影响,获取主线程堆栈,暂停主线程的运行。

卡顿监控方案二

对于线上卡顿监控,需要字节码插桩技术。

通过Gradle Plugin+ASM,编译期在每个方法开始和结束位置分别插入一行代码,统计耗时。例如微信Matrix使用的卡顿监控方案。注意问题:

  1. 避免方法数暴增:分配独立ID作为参数
  2. 过滤简单函数:添加黑明单降低非必要函数统计

微信Matrix做大量优化,包体积增加1%~2%,帧率下降2帧以内,灰度包使用。

ANR原理

  • Service Timeout:前台服务20s内未执行完成,后台服务是10s
  • BroadcastQueue Timeout:前台广播10s内执行完成,后台60s
  • ContentProvider Timeout:publish超时10s
  • InputDispatching Timeout:输入事件分发超过5s,包括按键和触摸事件。

ActivityManagerService api29

    // How long we allow a receiver to run before giving up on it.
    static final int BROADCAST_FG_TIMEOUT = 10*1000;
    static final int BROADCAST_BG_TIMEOUT = 60*1000;

ANR触发流程

埋炸弹

后台sevice调用:Context.startService--> AMS.startService--> ActiveService.startService--> ActiveService.realStartServiceLocked

    private final void realStartServiceLocked(ServiceRecord r,
            ProcessRecord app, boolean execInFg) throws RemoteException {
                // 1、发送delay消息(SERVICE_TIMEOUT_MSG)
                bumpServiceExecutingLocked(r, execInFg, "create");
                try {
                    //  2、通知AMS创建服务
                    app.thread.scheduleCreateService(r, r.serviceInfo,
                    mAm.compatibilityInfoForPackage(r.serviceInfo.applicationInfo),
                    app.getReportedProcState());
                }
            }

注释1内部调用scheduleServiceTimeoutLocked

    void scheduleServiceTimeoutLocked(ProcessRecord proc) {
        if (proc.executingServices.size() == 0 || proc.thread == null) {
            return;
        }
        Message msg = mAm.mHandler.obtainMessage(
                ActivityManagerService.SERVICE_TIMEOUT_MSG);
        msg.obj = proc;
        // 发送delay消息,前台服务是20s,后台服务是200s
        mAm.mHandler.sendMessageDelayed(msg,
                proc.execServicesFg ? SERVICE_TIMEOUT : SERVICE_BACKGROUND_TIMEOUT);
    }

注释2通知AMS启动服务前,注释1发送handler延迟消息,20s内(前台服务)没有处理完,则ActiveServices#serviceTimeout被调用。

拆炸弹

启动一个Service,先要经过AMS管理,然后AMS通知应用执行Service的生命周期,ActivityThread的handlerCreateService方法被调用。

    @UnsupportedAppUsage
    private void handleCreateService(CreateServiceData data) {
        try {
            Application app = packageInfo.makeApplication(false, mInstrumentation);
            service.attach(context, this, data.info.name, data.token, app,
                    ActivityManager.getService());
            // 1、service onCreate调用
            service.onCreate();
            mServices.put(data.token, service);
            try {
                // 2、拆炸弹
                ActivityManager.getService().serviceDoneExecuting(
                        data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
            } catch (RemoteException e) {
                throw e.rethrowFromSystemServer();
            }
        }
    }

注释1,Service的onCreate方法被调用 注释2,调用AMS的serviceDoneExecuting方法,最终会调用ActiveServices.serviceDoneExecutingLocked

    private void serviceDoneExecutingLocked(ServiceRecord r, boolean inDestroying,
            boolean finishing) {
                //移除delay消息
                mAm.mHandler.removeMessages(ActivityManagerService.SERVICE_TIMEOUT_MSG, r.app);

       }

onCreate调用后,就会移除delay消息,炸弹拆除。

引爆炸弹,假设Service的onCreate执行超过10s,那么炸弹就会引爆,也就是ActiveServices#serviceTimeout方法会被调用。api29

void serviceTimeout(ProcessRecord proc) {
        if (anrMessage != null) {
            proc.appNotResponding(null, null, null, null, false, anrMessage);
        }
}

所有ANR,最终带调用ProcessRecord的appNotResponding方法。api29

void appNotResponding(String activityShortComponentName, ApplicationInfo aInfo,
            String parentShortComponentName, WindowProcessController parentProcess,
            boolean aboveSystem, String annotation) {
        // 1、写入event log
        // Log the ANR to the event log.
        EventLog.writeEvent(EventLogTags.AM_ANR, userId, pid, processName, info.flags,
                    annotation);
        // 2、收集需要的log、anr、cpu等,放到StringBuilder中。
        // Log the ANR to the main log.
        StringBuilder info = new StringBuilder();
        info.setLength(0);
        info.append("ANR in ").append(processName);
        if (activityShortComponentName != null) {
            info.append(" (").append(activityShortComponentName).append(")");
        }
        info.append("\n");
        info.append("PID: ").append(pid).append("\n");
        if (annotation != null) {
            info.append("Reason: ").append(annotation).append("\n");
        }
        if (parentShortComponentName != null
                && parentShortComponentName.equals(activityShortComponentName)) {
            info.append("Parent: ").append(parentShortComponentName).append("\n");
        }

        ProcessCpuTracker processCpuTracker = new ProcessCpuTracker(true);
        // 3、dump堆栈信息,包括java堆栈和native堆栈,保存到文件中
        // For background ANRs, don't pass the ProcessCpuTracker to
        // avoid spending 1/2 second collecting stats to rank lastPids.
        File tracesFile = ActivityManagerService.dumpStackTraces(firstPids,
                (isSilentAnr()) ? null : processCpuTracker, (isSilentAnr()) ? null : lastPids,
                nativePids);
        String cpuInfo = null;
        // 4、输出ANR日志
        Slog.e(TAG, info.toString());
        if (tracesFile == null) {
            // 5、没有抓到tracesFile,发一个SIGNAL_QUIT信号
            // There is no trace file, so dump (only) the alleged culprit's threads to the log
            Process.sendSignal(pid, Process.SIGNAL_QUIT);
        }
        // 6、输出到drapbox
        mService.addErrorToDropBox("anr", this, processName, activityShortComponentName,
                parentShortComponentName, parentPr, annotation, cpuInfo, tracesFile, null);
        synchronized (mService) {
            // 7、后台ANR,直接杀进程
            if (isSilentAnr() && !isDebugging()) {
                kill("bg anr", true);
                return;
            }
            // 8、错误报告
            // Set the app's notResponding state, and look up the errorReportReceiver
            makeAppNotRespondingLocked(activityShortComponentName,
                    annotation != null ? "ANR " + annotation : "ANR", info.toString());
            // 9、弹出ANR dialog,会调用handleShowAnrUi方法
            Message msg = Message.obtain();
            msg.what = ActivityManagerService.SHOW_NOT_RESPONDING_UI_MSG;
            msg.obj = new AppNotRespondingDialog.Data(this, aInfo, aboveSystem);

            mService.mUiHandler.sendMessage(msg);
        }
  }
  1. 写入event log
  2. 写入main log
  3. 生成tracesFile
  4. 输出ANR logcat(控制台可以看到)
  5. 如果没有获取tracesFile,会发SIGNAL_QUIT信号,触发收集线程堆栈信息流程,写入traceFile
  6. 输出到drapbox
  7. 后台ANR,直接杀进程
  8. 错误报告
  9. 弹出ANR dialog 调用AppErrors#handleShowAnrUi方法。
ANR触发流程,埋炸弹--》拆炸弹的过程
启动Service,onCreate方法调用之前会使用Handler延时10s的消息,Service的onCreate方法执行完,会把延迟消息移除掉。
假如Service的onCreate方法耗时超过10s,延时消息就会被正常处理,触发ANR,收集cpu、堆栈消息,弹ANR dialog

抓取系统的data/anr/trace.txt文件,但是高版本系统需要root权限才能读取这个目录。

ANRWatchDog github.com/SalomonBrys…

自动检测ANR开源库

以上就是Android ANR原理分析的详细内容,更多关于Android ANR原理的资料请关注我们其它相关文章!

(0)

相关推荐

  • Android ANR(Application Not Responding)的分析

    Android ANR(Application Not Responding)的分析 ANR (Application Not Responding) ANR定义:在Android上,如果你的应用程序有一段时间响应不够灵敏,系统会向用户显示一个对话框,这个对话框称作应用程序无响应(ANR:Application Not Responding)对话框.用户可以选择"等待"而让程序继续运行,也可以选择"强制关闭".所以一个流畅的合理的应用程序中不能出现anr,而让用户每

  • Android开发中避免应用无响应的方法(Application Not Responding、ANR)

    App里发生的最糟糕的事是弹出应用无响应"Application Not Responding" (ANR) 对话框.本课讲的是如何保持应用响应,避免ANR. 什么触发ANR 通常,系统会在应用无法对用户输入响应时显示ANR.比如,如果一个应用在I/O操作上阻塞了(频繁请求网络)UI线程,系统无法处理用户输入事件.或者,在UI线程中,app花了大量时间在构建复杂的类,或在游戏中计算下一个动作.保证这些操作高效是很重要的,但最高效的代码也需要花费时间. 在任何情况下,都不要在UI线程执行

  • 通过Android trace文件分析死锁ANR实例过程

    对于从事Android开发的人来说,遇到ANR(Application Not Responding)是比较常见的问题.一般情况下,如果有ANR发生,系统都会在/data/anr/目录下生成trace文件,通过分析trace文件,可以定位产生ANR的原因.产生ANR的原因有很多,比如CPU使用过高.事件没有得到及时的响应.死锁等,下面将通过一次因为死锁导致的ANR问题,来说明如何通过trace文件分析ANR问题. 对应的部分trace文件内容如下: "PowerManagerService&qu

  • 浅谈Android ANR在线监控原理

    Android中的Watchdog 在Android中,Watchdog是用来监测关键服务是否发生了死锁,如果发生了死锁就kill进程,重启SystemServer Android的Watchdog是在SystemServer中进行初始化的,所以Watchdog是运行在SystemServer进程中 Watchdog是运行一个单独的线程中的,每次wait 30s之后就会发起一个监测行为,如果系统休眠了,那Watchdog的wait行为也会休眠,此时需要等待系统唤醒之后才会重新恢复监测 想要被Wa

  • 全面解析Android之ANR日志

    目录 一.概述 二.ANR产生机制 2.1 输入事件超时(5s) 2.2 广播类型超时(前台15s,后台60s) 2.3 服务超时(前台20s,后台200s) 2.4 ContentProvider 类型 三.导致ANR的原因 3.1 应用层导致ANR(耗时操作) 3.2 系统导致ANR 四.分析日志 4.1 CPU 负载 4.2 内存信息 4.3 堆栈消息 五.典型案例分析 5.1 主线程无卡顿,处于正常状态堆栈 5.2 主线程执行耗时操作 5.3 主线程被锁阻塞 5.4 CPU被抢占 5.5

  • Android ANR原理分析

    目录 卡顿原理 卡顿监控 ANR原理 卡顿原理 主线程有耗时操作会导致卡顿,卡顿超过阀值,触发ANR. 应用进程启动时候,Zygote会反射调用ActivityThread的main方法,启动loop循环. ActivityThread(api29) public static void main(String[] args) { Looper.prepareMainLooper(); ... Looper.loop(); throw new RuntimeException("Main thr

  • Android Handler 原理分析及实例代码

    Android Handler 原理分析 Handler一个让无数android开发者头疼的东西,希望我今天这边文章能为您彻底根治这个问题 今天就为大家详细剖析下Handler的原理 Handler使用的原因 1.多线程更新Ui会导致UI界面错乱 2.如果加锁会导致性能下降 3.只在主线程去更新UI,轮询处理 Handler使用简介 其实关键方法就2个一个sendMessage,用来接收消息 另一个是handleMessage,用来处理接收到的消息 下面是我参考疯狂android讲义,写的一个子

  • Android Broadcast原理分析之registerReceiver详解

    目录 1. BroadcastReceiver概述 2. BroadcastReceiver分类 3. registerReceiver流程图 4. 源码解析 4.1 ContextImpl.registerReceiverInternal 4.2 LoadedApk.getReceiverDispatcher 4.3 ActivityManagerService.registerReceiver 5. 总结 1. BroadcastReceiver概述 广播作为四大组件之一,在平时开发过程中会

  • 深入学习Android ANR 的原理分析及解决办法

    目录 一.ANR说明和原因 1.1 简介 1.2 原因 1.3 避免 二.ANR分析办法 2.1 ANR重现 2.2 ANR分析办法一:Log 2.3 ANR分析办法二:traces.txt 2.4 ANR分析办法三:Java线程调用分析 2.5 ANR分析办法四:DDMS分析ANR问题 三.造成ANR的原因及解决办法 四.ANR源码分析 4.1 Service造成的Service Timeout 4.2 BroadcastReceiver造成的BroadcastQueue Timeout 4.

  • Android 系统服务TelecomService启动过程原理分析

    由于一直负责的是Android Telephony部分的开发工作,对于通信过程的上层部分Telecom服务以及UI都没有认真研究过.最近恰好碰到一个通话方面的问题,涉及到了Telecom部分,因而就花时间仔细研究了下相关的代码.这里做一个简单的总结.这篇文章,主要以下两个部分的内容: 什么是Telecom服务?其作用是什么? Telecom模块的启动与初始化过程: 接下来一篇文章,主要以实际通话过程为例,分析下telephony收到来电后如何将电话信息发送到Telecom模块以及Telecom是

  • android上实现0.5px线条的原理分析

    由于安卓手机无法识别border: 0.5px,因此我们要用0.5px的话必须要借助css3中的-webkit-transform:scale缩放来实现. 原理:将伪元素的宽设为200%,height设为1px通过-webkit-transform:scale(.5)来进行缩小一倍,这样就得到border为0.5的边框 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF

  • Android ANR分析trace文件的产生流程详情

    目录 前言 接着分析最后一步向收集到的进程发送信号 前言 首先收集需要dump trace的进程并给对应进程发送dump trace的信号 1.当一些带有超时机制的系统消息(如:Service的创建)判定超时后,会调用系统服务AMS接口,收集ANR相关信息并存档(data/anr/trace, data/system/dropbox) 2.进入到AMS中,AppError会先进行筛选(1.当前进程正在进行dump流程 2.已经发生crash 3. 已经被系统kill 4.系统是否正在关机等情况)

  • Android AccessibilityService 事件分发原理分析总结

    目录 AccessibilityService 监听事件的调用逻辑 onAccessibilityEvent onIntercept AccessibilityService 事件的外部来源 AccessibilityServiceInfo AccessibilityManager AccessibilityManagerService AccessibilityServiceConnection 前言: 在了解了无障碍服务基础使用之后,我们来探究一下 AccessibilityService

随机推荐