你知道App为什么会Crash吗？

1概述

目录

前言

每一个Android开发同学在项目开发过程中肯定都遇到过各式各样的Crash问题，大家都非常不希望程序发生Crash。

那么问题来了，你真的了解Crash吗？

在这分享一份整理了2个月的Android进阶面试解析笔记文档，包括了知识点笔记和高频面试问题解析及部分知识点视频讲解给大家！为了不影响阅读，在这以图片展示部分内容于目录截图，有需要的朋友麻烦点赞后点击下面在线链接获取免费领取方式吧！
阿里P6P7【安卓】进阶资料分享+加薪跳槽必备面试题

2 App 为什么会发生Crash?

最近在思考一个问题，为什么Android程序发生空指针等异常时，会导致应用会崩溃，进程结束。

而java web程序发生这些异常，只要有其他线程还在运行，虚拟机就不会关闭，进程也不会结束。

我在App中模拟了一个数组越界异常，Android系统会帮我们打印异常日志。

主线程异常

子线程异常

扫描二维码关注公众号，回复： 9156405 查看本文章

每当异常发生的时候，我们往往都会通过查看日志来解决。

那么我们是不是可以通过查看打印异常日志的代码，来找到Android系统是如何抛出这些未捕获的异常，以及Android在出现未捕获异常的时候为什么会发生Crash。

我们找到了com.android.internal.os.RuntimeInit类，这里我们仅贴出我们需要的代码

public class RuntimeInit {
    final static String TAG = "AndroidRuntime";

    ....

    private static class LoggingHandler implements Thread.UncaughtExceptionHandler {
        public volatile boolean mTriggered = false;

        @Override
        public void uncaughtException(Thread t, Throwable e) {
            mTriggered = true;

            if (mCrashing) return;
                //打印异常日志
            if (mApplicationObject == null && (Process.SYSTEM_UID == Process.myUid())) {
                Clog_e(TAG, "*** FATAL EXCEPTION IN SYSTEM PROCESS: " + t.getName(), e);
            } else {
                StringBuilder message = new StringBuilder();
                message.append("FATAL EXCEPTION: ").append(t.getName()).append("\n");
                final String processName = ActivityThread.currentProcessName();
                if (processName != null) {
                    message.append("Process: ").append(processName).append(", ");
                }
                message.append("PID: ").append(Process.myPid());
                Clog_e(TAG, message.toString(), e);
            }
        }
    }

    private static class KillApplicationHandler implements Thread.UncaughtExceptionHandler {
        private final LoggingHandler mLoggingHandler;
        public KillApplicationHandler(LoggingHandler loggingHandler) {
            this.mLoggingHandler = Objects.requireNonNull(loggingHandler);
        }

        @Override
        public void uncaughtException(Thread t, Throwable e) {
            try {
                ensureLogging(t, e);

                if (mCrashing) return;
                mCrashing = true;
                if (ActivityThread.currentActivityThread() != null) {
                    ActivityThread.currentActivityThread().stopProfiling();
                }

                ActivityManager.getService().handleApplicationCrash(
                        mApplicationObject, new ApplicationErrorReport.ParcelableCrashInfo(e));
            } catch (Throwable t2) {
                if (t2 instanceof DeadObjectException) {
                } else {
                    try {
                        Clog_e(TAG, "Error reporting crash", t2);
                    } catch (Throwable t3) {
                    }
                }
            } finally {
                //杀死进程
                Process.killProcess(Process.myPid());
                System.exit(10);
            }
        }
        private void ensureLogging(Thread t, Throwable e) {
            if (!mLoggingHandler.mTriggered) {
                try {
                    mLoggingHandler.uncaughtException(t, e);
                } catch (Throwable loggingThrowable) {
                }
            }
        }

      ....
    }


    protected static final void commonInit() {
                //设置异常处理回调
        LoggingHandler loggingHandler = new LoggingHandler();
        Thread.setUncaughtExceptionPreHandler(loggingHandler);
        Thread.setDefaultUncaughtExceptionHandler(new KillApplicationHandler(loggingHandler));

                ....
    }

RuntimeInit有两个的内部类，LoggingHandler和KillApplicationHandler。

很显然，LoggingHandler的作用是打印异常日志，而KillApplicationHandler就是App发生Crash的真正原因，其内部调用了Process.killProcess(Process.myPid())来杀死发生Uncaught异常的进程。

我们还发现，这两个内部类都实现了Thread.UncaughtExceptionHandler接口。

分别通过Thread.setUncaughtExceptionPreHandler和Thread.setDefaultUncaughtExceptionHandler方法进行注册。

• Thread.setUncaughtExceptionPreHandler，覆盖所有线程，会在回调DefaultUncaughtExceptionHandler之前调用，只能在Android Framework内部调用该方法

• Thread.setDefaultUncaughtExceptionHandler，如果在任意线程中调用即可覆盖所有线程的异常，可以在应用层调用，每次调用传入的Thread.UncaughtExceptionHandler都会覆盖上一次的，即我们可以手动覆盖系统实现的KillApplicationHandler

• new Thread().setUncaughtExceptionHandler()，只可以覆盖当前线程的异常，如果某个Thread有定义UncaughtExceptionHandler，则忽略全局DefaultUncaughtExceptionHandler

小结：Uncaught异常发生时会终止线程，此时，系统便会通知UncaughtExceptionHandler，告诉它被终止的线程以及对应的异常， 然后便会调用uncaughtException函数。

如果该handler没有被显式设置，则会调用对应线程组的默认handler。如果我们要捕获该异常，必须实现我们自己的handler。

3我们能让应用不发生Crash吗？

上面说到了我们可以在应用层调用Thread.setDefaultUncaughtExceptionHandler来实现所有线程的Uncaught异常的监听，并且会覆盖系统的默认实现的KillApplicationHandler，这样我们就可以做到让线程发生Uncaught异常的时候只是当前杀死线程，而不会杀死整个进程。

这适用于我们的子线程发生Uncaught异常，如果我们的主线程发生Uncaught异常呢？

主线程都被销毁了，这和Crash似乎就没什么区别的。

那么我们有办法让主线程发生Uncaught异常也不会发生Crash吗？

答案是有的，但在讲如何实现之前我们先来介绍一些知识点。

我们知道Java程序开始于一个Main函数，如果只是顺序执行有限任务很快这个Main函数所在的线程就结束了。

如何来保持Main函数一直存活并不断的处理已知或未知的任务呢？

• 采用死循环。但是死循环的一次循环需要处理什么任务。如果任务暂时没有，也要程序保持活跃的等待状态怎么办？

• 如果有两个线程或者多个线程如何来协作以完成一个微型系统任务？

如果熟悉Android Handler机制的话，我们会了解到整个Android系统其实是消息驱动的。

Looper内部是一个死循环，不断地MessageQueue内部取出消息，由消息来通知做什么任务。

比如收到msg=H.LAUNCH_ACTIVITY，则调用ActivityThread.handleLaunchActivity()方法，最终会通过反射机制，创建Activity实例，然后再执行Activity.onCreate()等方法；

再比如收到msg=H.PAUSE_ACTIVITY，则调用ActivityThread.handlePauseActivity()方法，最终会执行Activity.onPause()等方法。

public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;
    ...
    for (;;) {
        //从消息队列中取出Message
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
        //派发发消息到对应的Handler,target就是Handler的实例
        msg.target.dispatchMessage(msg);
        ....
        //释放消息占据的资源
        msg.recycleUnchecked();
    }
}

那么我们有没有想过一个问题，Looper.loop是在ActiivtyThread被调用的，也就是主线程中，那么主线程中死循环为什么不会导致应用卡死呢？

这里就涉及到Linux pipe/epoll机制，简单说就是在主线程的MessageQueue没有消息时，便阻塞在Looper.loop()的queue.next()中的nativePollOnce()方法，此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生，通过往pipe管道写端写入数据来唤醒主线程工作。这里采用的epoll机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质同步I/O，即读写是阻塞的。所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源。

当收到不同Message时则采用相应措施：一旦退出消息循环，那么你的程序也就可以退出了。从消息队列中取消息可能会阻塞，取到消息会做出相应的处理。如果某个消息处理时间过长，就可能会影响UI线程的刷新速率，造成卡顿的现象

在子线程中，如果手动为其创建了Looper，那么在所有的事情完成以后应该调用quit()方法来终止消息循环，否则这个子线程就会一直处于等待（阻塞）状态，而如果退出Looper以后，这个线程就会立刻（执行所有方法并）终止，因此建议不需要的时候终止Looper

简单总结一下就是当没有消息时，native层的方法做了阻塞处理，所以Looper.loop()死循环不会卡死应用。

我们整个系统都是基于消息机制，再回过头去看一眼上面的主线程异常日志堆栈信息，是不是会经过Looper.loop()，所以其实我们只需要try catch Looper.loop()即可捕获主线程异常。

代码如下所示

public class CrashCatch {

    private CrashHandler mCrashHandler;

    private static CrashCatch mInstance;

    private CrashCatch(){

    }

    private static CrashCatch getInstance(){
        if(mInstance == null){
            synchronized (CrashCatch.class){
                if(mInstance == null){
                    mInstance = new CrashCatch();
                }
            }
        }

        return mInstance;
    }

    public static void init(CrashHandler crashHandler){
        getInstance().setCrashHandler(crashHandler);
    }

    private void setCrashHandler(CrashHandler crashHandler){

        mCrashHandler = crashHandler;
        //主线程异常拦截
        new Handler(Looper.getMainLooper()).post(new Runnable() {
            @Override
            public void run() {
                for (;;) {
                    try {
                        Looper.loop();
                    } catch (Throwable e) {
                        if (mCrashHandler != null) {
                          //处理异常
                    mCrashHandler.handlerException(Looper.getMainLooper().getThread(), e);
                        }
                    }
                }
            }
        });

         //所有线程异常拦截，由于主线程的异常都被我们catch住了，所以下面的代码拦截到的都是子线程的异常
        Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                if(mCrashHandler!=null){
                  //处理异常
                   mCrashHandler.handlerException(t,e);
                }
            }
        });


    }

    public interface CrashHandler{
        void handlerException(Thread t,Throwable e);
    }
}

原理很简单，就是通过Handler往主线程的MessageQueue中添加一个Runnable，当主线程执行到该Runnable时，会进入我们的while死循环。

如果while内部是空的就会导致代码卡在这里，最终导致ANR，但我们在while死循环中又调用了Looper.loop()，这就导致主线程又开始不断的读取queue中的Message并执行，这样就可以保证以后主线程的所有异常都会从我们手动调用的Looper.loop()处抛出，一旦抛出就会被try{}catch捕获，这样主线程就不会crash了。

如果没有这个while的话那么主线程下次抛出异常时我们就又捕获不到了，这样App就又crash了，所以我们要通过while让每次crash发生后都再次进入消息循环，while的作用仅限于每次主线程抛出异常后迫使主线程再次进入消息循环。

为什么要通过new Handler.post方式而不是直接在主线程中任意位置执行 while (true) { try { Looper.loop(); } catch (Throwable e) {} }。

这是因为该方法是个死循环，若在主线程中，比如在Activity的onCreate中执行时会导致while后面的代码得不到执行，Activity的生命周期也就不能完整执行，通过Handler.post方式可以保证不影响该条消息中后面的逻辑。

使用起来也非常简单

CrashCatch.getInstance().setCrashHandler(new CrashHandler(){
    @Override
        void handlerException(Thread t,Throwable e){
        //try catch 以防handlerException内部再次抛出异常，导致循环调用handlerException
        try{
          //TODO 实现自己的异常处理逻辑
        }catch(Exeception e){

        }
        }
})

4总结

很多时候由于一些微不足道的bug导致app崩溃很可惜，android默认的异常杀进程机制简单粗暴，但很多时候让app崩溃其实并不是一个特别好的选择。

有些bug可能是系统bug，对于这些难以预料的系统bug我们不好绕过，还有一些bug是我们自己编码造成的，对于有些bug来说直接忽略掉的话可能只是导致部分不重要的功能没法使用而已，又或者对用户来说完全没有影响，这种情况总比每次都崩溃要好很多。

我们还可以捕获到异常后做一些自己的逻辑判断。

本文主要讲原理，具体大家如何使用如何取舍，还是视自己项目的实际情况而定。