Android 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原理的资料请关注179885.Com其它相关文章!

猜你在找的Android ANR原理分析相关文章

ViewModel 是 Jetpack 的一部分。 ViewModel 类旨在以注重生命周期的方式存储和管理界面相关的数据。ViewModel 类让数据可在发生屏幕旋转等配置更改后继续留存。
在Android系统中,所有的应用程序进程以及系统服务进程SystemServer都是由Zygote进程孕育(fork)出来的,这也许就是为什么要把它称为Zygote(受精卵)的原因吧。由于Zygote
突然发现微信下拉小程序入口动画非常细腻,比较好奇,所以仿照他做了一个,并不是很完美,部分效果还没完成,但总体自我感觉还不错,效果见下文
在android的应用中越来越多的包含了网络互动功能,这就带来了注册,登陆账号功能,这篇文章主要给大家介绍了关于Android实现简易登陆注册逻辑的相关资料,需求的大佬
生成图片保存是常见的需求,几乎任何的app都能用到这个需求,本文将提供一种思路,有此需求的朋友可以参考下
像Unity3D下的RTMP或RTSP播放器一样,好多开发者苦于在Unity环境下,如何高效率低延迟的把数据采集并编码实时推送到流媒体服务器,实现Unity场景下的低延迟推拉流方案
侧边弹窗是在左边,需要定位好位置,实现原理其实就是进出动效,用位移加透明度效果来控制,下面通过代码给大家介绍android 实现侧边弹窗,需要的朋友参考下吧
脱色是将彩色图像转换为灰度图像的过程。同时,它也是数字打印,风格化的黑白照片渲染以及许多单通道图像处理应用程序中的基本工具。本文讲述基于OpenCV实现图像脱色
目前的应用市场上,使用毛玻璃效果的APP随处可见,比如用过微信语音聊天的人可以发现,语音聊天页面就使用了高斯模糊效果。本文就使用Android仿写一个这样的效果
针对图像多通道的分离与混合,OpenCV 4中提供了split()函数和merge()函数用于解决这些需求。本文讲解一下Android如何调用这些函数实现多通道分离与合并
dex简单说就是优化后的android版.exe。每个apk安装包里都有。相对于PC上的java虚拟机能运行.class,android上的Davlik虚拟机能运行.dex。本文将着重介绍dex优化对A
Android 开发中,NE一直是不可忽略却又异常难解的一个问题,原因是这里面涉及到了跨端开发和分析,需要同时熟悉 Java,C&C++,并且需要熟悉 NDK开发,并且解决起来不像 Java