Android 全局异常捕获DefaultUncaughtExceptionHandler与Cockroach

前言

    Android中虽然可以通过设置 Thread.setDefaultUncaughtExceptionHandler来捕获全局的所有线程的异常,但主线程抛出异常时仍旧会导致activity闪退,app进程重启。使用Cockroach后就可以保证不管怎样抛异常activity都不会闪退,app进程也不会重启。

DefaultUncaughtExceptionHandler使用。

public class CrashCatchHandler implements UncaughtExceptionHandler {

    public static final String TAG = "CrashCatchHandler";
    private static CrashCatchHandler crashHandler = new CrashCatchHandler();
    private Context mContext;
    private UncaughtExceptionHandler mDefaultCaughtExceptionHandler;

    /**
     * 饿汉单例模式(静态)
     *
     * @return
     */
    public static CrashCatchHandler getInstance() {
        return crashHandler;
    }

    /**
     * 初始化
     *
     * @param context
     */
    public void init(Context context) {
        mContext = context;
        //获取默认的系统异常捕获器
        mDefaultCaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();
        //把当前的crash捕获器设置成默认的crash捕获器
        Thread.setDefaultUncaughtExceptionHandler(this);
    }

    @Override
    public void uncaughtException(Thread thread, Throwable throwable) {
        if (!handleException(throwable) && mDefaultCaughtExceptionHandler != null) {
            //如果用户没有处理则让系统默认的异常处理器来处理
            mDefaultCaughtExceptionHandler.uncaughtException(thread, throwable);
        }else {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                LogUtils.e(TAG, "error : "+ e);
            }
            //退出程序
             AppUtil.restarteApp(mContext);
        }
    }
    /**
     * 自定义错误处理
     * @param ex
     * @return true:如果处理了该异常信息;否则返回false
     */
    private boolean handleException(Throwable ex) {
        if (ex == null) {
            return false;
        }
        final String msg = ex.getLocalizedMessage();
        if (msg == null) {
            return false;
        }

        //使用Toast来显示异常信息
        new Thread() {
            @Override
            public void run() {
                Looper.prepare();
                Toast.makeText(mContext, "很抱歉,程序出现异常!", Toast.LENGTH_LONG).show();
                Looper.loop();
            }
        }.start();
        return true;
    }
}

使用很方便,在程序入口,Application类中初始化即可。


Cockroach 的使用

自定义Application继承自android的Application,并在Application中装载,越早初始化越好,可以在Aplication的onCreate中初始化,当然也可以根据需要在任意地方(不一定要在主线程)装载,在任意地方卸载。可以多次装载和卸载。

例如:

[java]  view plain  copy
  1. import android.app.Application;  
  2. import android.os.Handler;  
  3. import android.os.Looper;  
  4. import android.util.Log;  
  5. import android.widget.Toast;  
  6.   
  7. /** 
  8.  * Created by wanjian on 2017/2/14. 
  9.  */  
  10.   
  11. public class App extends Application {  
  12.   
  13.     @Override  
  14.     public void onCreate() {  
  15.         super.onCreate();  
  16.   
  17.         Cockroach.install(new Cockroach.ExceptionHandler() {  
  18.   
  19.            // handlerException内部建议手动try{  你的异常处理逻辑  }catch(Throwable e){ } ,以防handlerException内部再次抛出异常,导致循环调用handlerException  
  20.   
  21.             @Override  
  22.             public void handlerException(final Thread thread, final Throwable throwable) {  
  23.             //开发时使用Cockroach可能不容易发现bug,所以建议开发阶段在handlerException中用Toast谈个提示框,  
  24.             //由于handlerException可能运行在非ui线程中,Toast又需要在主线程,所以new了一个new Handler(Looper.getMainLooper()),  
  25.             //所以千万不要在下面的run方法中执行耗时操作,因为run已经运行在了ui线程中。  
  26.             //new Handler(Looper.getMainLooper())只是为了能弹出个toast,并无其他用途  
  27.                 new Handler(Looper.getMainLooper()).post(new Runnable() {  
  28.                     @Override  
  29.                     public void run() {  
  30.                         try {  
  31.                         //建议使用下面方式在控制台打印异常,这样就可以在Error级别看到红色log  
  32.                             Log.e("AndroidRuntime","--->CockroachException:"+thread+"<---",throwable);  
  33.                             Toast.makeText(App.this"Exception Happend\n" + thread + "\n" + throwable.toString(), Toast.LENGTH_SHORT).show();  
  34. //                        throw new RuntimeException("..."+(i++));  
  35.                         } catch (Throwable e) {  
  36.   
  37.                         }  
  38.                     }  
  39.                 });  
  40.             }  
  41.         });  
  42.     }  
  43. }  

载 Cockroach

[java]  view plain  copy
  1. Cockroach.uninstall();  

测试

装载Cockroach后点击view抛出异常和new Handler中抛出异常

[java]  view plain  copy
  1.         final TextView textView = (TextView) findViewById(R.id.text);  
  2.         findViewById(R.id.install).setOnClickListener(new View.OnClickListener() {  
  3.             @Override  
  4.             public void onClick(View v) {  
  5.                 textView.setText("已安装 Cockroach");  
  6.                 install();  
  7.             }  
  8.         });  
  9.   
  10.         findViewById(R.id.uninstall).setOnClickListener(new View.OnClickListener() {  
  11.             @Override  
  12.             public void onClick(View v) {  
  13.                 textView.setText("已卸载 Cockroach");  
  14.                 Cockroach.uninstall();  
  15.             }  
  16.         });  
  17.   
  18.         findViewById(R.id.but1).setOnClickListener(new View.OnClickListener() {  
  19.             @Override  
  20.             public void onClick(View v) {  
  21.                 throw new RuntimeException("click exception...");  
  22.             }  
  23.         });  
  24.   
  25.         findViewById(R.id.but2).setOnClickListener(new View.OnClickListener() {  
  26.             @Override  
  27.             public void onClick(View v) {  
  28.                 new Handler().post(new Runnable() {  
  29.                     @Override  
  30.                     public void run() {  
  31.                         throw new RuntimeException("handler exception...");  
  32.                     }  
  33.                 });  
  34.             }  
  35.         });  
  36.   
  37.         findViewById(R.id.but3).setOnClickListener(new View.OnClickListener() {  
  38.             @Override  
  39.             public void onClick(View v) {  
  40.                 new Thread() {  
  41.                     @Override  
  42.                     public void run() {  
  43.                         super.run();  
  44.                         throw new RuntimeException("new thread exception...");  
  45.                     }  
  46.                 }.start();  
  47.             }  
  48.         });  
  49.   
  50.         findViewById(R.id.but4).setOnClickListener(new View.OnClickListener() {  
  51.             @Override  
  52.             public void onClick(View v) {  
  53.                 startActivity(new Intent(getApplicationContext(), SecActivity.class));  
  54.             }  
  55.         });  
  56.   
  57.     }  
  58.   
  59.     private void install() {  
  60.         Cockroach.install(new Cockroach.ExceptionHandler() {  
  61.             @Override  
  62.             public void handlerException(final Thread thread, final Throwable throwable) {  
  63.   
  64.                 Log.d("Cockroach""MainThread: " + Looper.getMainLooper().getThread() + "  curThread: " + Thread.currentThread());  
  65.   
  66.                 new Handler(Looper.getMainLooper()).post(new Runnable() {  
  67.                     @Override  
  68.                     public void run() {  
  69.                         try {  
  70.   
  71.                             Log.e("AndroidRuntime","--->CockroachException:"+thread+"<---",throwable);  
  72.                             Toast.makeText(getApplicationContext(), "Exception Happend\n" + thread + "\n" + throwable.toString(), Toast.LENGTH_SHORT).show();  
  73. //                        throw new RuntimeException("..."+(i++));  
  74.                         } catch (Throwable e) {  
  75.   
  76.                         }  
  77.                     }  
  78.                 });  
  79.             }  
  80.         });  
  81.     }  

捕获到的堆栈如下,可以看到都已经被 at com.wanjian.cockroach.Cockroach$1.run(Cockroach.java:47) 拦截,APP没有任何影响,没有闪退,也没有重启进程

[java]  view plain  copy
  1. 02-16 09:58:00.660 21199-21199/wj.com.fuck E/AndroidRuntime: --->CockroachException:Thread[main,5,main]<---  
  2.                                                              java.lang.RuntimeException: click exception...  
  3.                                                                  at wj.com.fuck.MainActivity$3.onClick(MainActivity.java:53)  
  4.                                                                  at android.view.View.performClick(View.java:4909)  
  5.                                                                  at android.view.View$PerformClick.run(View.java:20390)  
  6.                                                                  at android.os.Handler.handleCallback(Handler.java:815)  
  7.                                                                  at android.os.Handler.dispatchMessage(Handler.java:104)  
  8.                                                                  at android.os.Looper.loop(Looper.java:194)  
  9.                                                                  at com.wanjian.cockroach.Cockroach$1.run(Cockroach.java:47)  
  10.                                                                  at android.os.Handler.handleCallback(Handler.java:815)  
  11.                                                                  at android.os.Handler.dispatchMessage(Handler.java:104)  
  12.                                                                  at android.os.Looper.loop(Looper.java:194)  
  13.                                                                  at android.app.ActivityThread.main(ActivityThread.java:5826)  
  14.                                                                  at java.lang.reflect.Method.invoke(Native Method)  
  15.                                                                  at java.lang.reflect.Method.invoke(Method.java:372)  
  16.                                                                  at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:1009)  
  17.                                                                  at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:804)  
  18. 02-16 09:58:12.401 21199-21199/wj.com.fuck E/AndroidRuntime: --->CockroachException:Thread[main,5,main]<---  
  19.                                                              java.lang.RuntimeException: handler exception...  
  20.                                                                  at wj.com.fuck.MainActivity$4$1.run(MainActivity.java:63)  
  21.                                                                  at android.os.Handler.handleCallback(Handler.java:815)  
  22.                                                                  at android.os.Handler.dispatchMessage(Handler.java:104)  
  23.                                                                  at android.os.Looper.loop(Looper.java:194)  
  24.                                                                  at com.wanjian.cockroach.Cockroach$1.run(Cockroach.java:47)  
  25.                                                                  at android.os.Handler.handleCallback(Handler.java:815)  
  26.                                                                  at android.os.Handler.dispatchMessage(Handler.java:104)  
  27.                                                                  at android.os.Looper.loop(Looper.java:194)  
  28.                                                                  at android.app.ActivityThread.main(ActivityThread.java:5826)  
  29.                                                                  at java.lang.reflect.Method.invoke(Native Method)  
  30.                                                                  at java.lang.reflect.Method.invoke(Method.java:372)  
  31.                                                                  at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:1009)  
  32.                                                                  at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:804)  
  33. 02-16 09:58:13.241 21199-21199/wj.com.fuck E/AndroidRuntime: --->CockroachException:Thread[Thread-26326,5,main]<---  
  34.                                                              java.lang.RuntimeException: new thread exception...  
  35.                                                                  at wj.com.fuck.MainActivity$5$1.run(MainActivity.java:76)  
  36.   
  37. 当卸载Cockroach后再在click中抛出异常,日志如下  
  38.   
  39. 02-16 09:59:01.251 21199-21199/wj.com.fuck E/AndroidRuntime: FATAL EXCEPTION: main  
  40.                                                              Process: wj.com.fuck, PID: 21199  
  41.                                                              java.lang.RuntimeException: click exception...  
  42.                                                                  at wj.com.fuck.MainActivity$3.onClick(MainActivity.java:53)  
  43.                                                                  at android.view.View.performClick(View.java:4909)  
  44.                                                                  at android.view.View$PerformClick.run(View.java:20390)  
  45.                                                                  at android.os.Handler.handleCallback(Handler.java:815)  
  46.                                                                  at android.os.Handler.dispatchMessage(Handler.java:104)  
  47.                                                                  at android.os.Looper.loop(Looper.java:194)  
  48.                                                                  at android.app.ActivityThread.main(ActivityThread.java:5826)  
  49.                                                                  at java.lang.reflect.Method.invoke(Native Method)  
  50.                                                                  at java.lang.reflect.Method.invoke(Method.java:372)  
  51.                                                                  at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:1009)  
  52.                                                                  at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:804)  

可以看到 at com.wanjian.cockroach.Cockroach$1.run(Cockroach.java:47) 没有拦截,并且APP crash了。

注意

  • 当主线程或子线程抛出异常时都会调用exceptionHandler.handlerException(Thread thread, Throwable throwable)

  • exceptionHandler.handlerException可能运行在非UI线程中。

  • handlerException内部建议手动try{ 你的异常处理逻辑 }catch(Throwable e){ } ,以防handlerException内部再次抛出异常,导致循环调用handlerException

  • 若设置了Thread.setDefaultUncaughtExceptionHandler则可能无法捕获子线程异常。

虽然可以捕获到所有异常,但可能会导致一些莫名其妙的问题,比如view初始化时发生了异常,异常后面的代码得不到执行,虽然不 会导致app crash但view内部已经出现了问题,运行时就会出现很奇葩的现象。再比如activity声明周期方法中抛出了异常,则生 命周期就会不完整,从而导致各种奇葩的现象。

虽然会导致各种奇葩问题发生,但可以最大程度的保证APP正常运行,很多时候我们希望主线程即使抛出异常也不影响app的正常使用,比如我们 给某个view设置背景色时,由于view是null就会导致app crash,像这种问题我们更希望即使view没法设置颜色也不要crash,这 时Cockroach就可以满足你的需求。

handlerException(final Thread thread, final Throwable throwable)内部建议请求自己服务器决定该如何处理该异常,是 直接忽略还是杀死APP又或者其他操作。

Cockroach采用android标准API编写,无依赖,足够轻量,轻量到只有不到100行代码,一般不会存在兼容性问题,也不存在性能上的问题,可以兼容所有android版本。

已上传到jcenter, compile 'com.wanjian:cockroach:0.0.5'

原理分析:

android中最重要的就是Handler机制了,简单来说Handler机制就是在一个死循环内部不断取走阻塞队列头部的Message,这个阻塞队列在主线程中是唯一的,当没有Message时,循环就阻塞,当一旦有Message时就立马被主线程取走并执行Message。

查看android源码可以发现在ActivityThread中main方法(main方法签名 public static void main(String[] args){},这个main方法是静态的,公有的,可以理解为应用的入口)最后执行了Looper.loop();,此方法内部是个死循环(for(;;)循环),所以一般情况下主线程是不会退出的,除非抛出异常。queue.next();就是从阻塞队列里取走头部的Message,当没有Message时主线程就会阻塞在这里,一有Message就会继续往下执行。android的view绘制,事件分发,activity启动,activity的生命周期回调等等都是一个个的Message,android会把这些Message插入到主线程中唯一的queue中,所有的消息都排队等待主线程的执行。

ActivityThread的main方法如下:

[java]  view plain  copy
  1. public static void main(String[] args) {  
  2.           
  3.      ...  
  4.        Looper.prepareMainLooper();//创建主线程唯一的阻塞队列queue  
  5.        ...  
  6.        ActivityThread thread = new ActivityThread();  
  7.        thread.attach(false);//执行初始化,往queue中添加Message等  
  8.        ...  
  9.        Looper.loop();//开启死循环,挨个执行Message  
  10.   
  11.        throw new RuntimeException("Main thread loop unexpectedly exited");  
  12.    }  


Looper.loop()关键代码如下:

[java]  view plain  copy
  1. for (;;) {  
  2.          Message msg = queue.next(); // might block  
  3.          ...  
  4.          msg.target.dispatchMessage(msg);//执行Message  
  5.          ...  
  6. }  

android消息机制伪代码如下:

[java]  view plain  copy
  1. public class ActivityThread {  
  2.   
  3.     public static void main(String[]args){  
  4.           
  5.         Queue queue=new Queue();// 可以理解为一个加锁的,可以阻塞线程的ArrayList  
  6.           
  7.         queue.add(new Message(){  
  8.             void run(){  
  9.                 ...  
  10.                 print("android 启动了,下一步该往queue中插入启动主Activity的Message了");  
  11.                 Message msg=getMessage4LaunchMainActivity();  
  12.                 queue.add(msg);  
  13.             }  
  14.           
  15.         });  
  16.           
  17.         for(;;){//开始死循环,for之后的代码永远也得不到执行  
  18.             Message  msg=queue.next();  
  19.               
  20.             msg.run();  
  21.         }  
  22.     }  
  23. }  

看了上面的分析相信大家对android的消息机制很清楚了。 关于Handler机制更多内容可以看这  java工程实现Handler机制代码

下面我们看一下Cockroach的核心代码

[java]  view plain  copy
  1.  new Handler(Looper.getMainLooper()).post(new Runnable() {  
  2.             @Override  
  3.             public void run() {  
  4.                //主线程异常拦截  
  5.                 while (true) {  
  6.                     try {  
  7.                         Looper.loop();//主线程的异常会从这里抛出  
  8.                     } catch (Throwable e) {  
  9.                                                   
  10.                     }  
  11.                 }  
  12.             }  
  13.         });  
  14.          
  15.         sUncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();  
  16.          //所有线程异常拦截,由于主线程的异常都被我们catch住了,所以下面的代码拦截到的都是子线程的异常  
  17.         Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {  
  18.             @Override  
  19.             public void uncaughtException(Thread t, Throwable e) {  
  20.                   
  21.             }  
  22. });  

原理很简单,就是通过Handler往主线程的queue中添加一个Runnable,当主线程执行到该Runnable时,会进入我们的while死循环,如果while内部是空的就会导致代码卡在这里,最终导致ANR,但我们在while死循环中又调用了Looper.loop(),这就导致主线程又开始不断的读取queue中的Message并执行,这样就可以保证以后主线程的所有异常都会从我们手动调用的Looper.loop()处抛出,一旦抛出就会被try{}catch捕获,这样主线程就不会crash了,如果没有这个while的话那么主线程下次抛出异常时我们就又捕获不到了,这样APP就又crash了,所以我们要通过while让每次crash发生后都再次进入消息循环,while的作用仅限于每次主线程抛出异常后迫使主线程再次进入消息循环。我们可以用下面的伪代码来表示:

[java]  view plain  copy
  1. public class ActivityThread {  
  2.   
  3.     public static void main(String[]args){  
  4.           
  5.         Queue queue=new Queue();// 可以理解为一个加锁的,可以阻塞线程的ArrayList  
  6.           
  7.         ...  
  8.           
  9.         for(;;){//开始死循环,for之后的代码永远也得不到执行  
  10.             Message  msg=queue.next();  
  11.               
  12.             //如果msg 是我们post的Runnable就会执行如下代码  
  13.                 //我们post的Runnable中的代码  
  14.                   while (true) {  
  15.                     try {  
  16.                          for(;;){//所有主线程的异常都会从msg.run()中抛出,所以我们加一个try{}catch来捕获所有主线程异常,捕获到后再次强迫进入循环,不断读取queue中消息并执行  
  17.                             Message  msg=queue.next();  
  18.                             msg.run();  
  19.                          }  
  20.                          
  21.                     } catch (Throwable e) {  
  22.                       
  23.                     }  
  24.             //否则执行其他逻辑    
  25.         }  
  26.     }  

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

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


转自“打不死的小强,永不crash的Android”


亲测,唯不足之处是,在Activity中的生命周期方法里异常之后,crash到但未能处理Activity,导致假死状态。

下面贴出code:

Cockroach:

[java]  view plain  copy
  1. package com.support.framework.crash;  
  2.   
  3. import android.os.Binder;  
  4. import android.os.Handler;  
  5. import android.os.Looper;  
  6.   
  7. import com.support.BaseApp;  
  8.   
  9. /** 
  10.  * Created by wanjian on 2017/2/14. 
  11.  */  
  12.   
  13. public final class Cockroach {  
  14.   
  15.     public interface ExceptionHandler {  
  16.   
  17.         void handlerException(Thread thread, Throwable throwable);  
  18.     }  
  19.   
  20.     private Cockroach() {  
  21.     }  
  22.   
  23.     private static ExceptionHandler sExceptionHandler;  
  24.     private static Thread.UncaughtExceptionHandler sUncaughtExceptionHandler;  
  25.     private static boolean sInstalled = false;//标记位,避免重复安装卸载  
  26.   
  27.     /** 
  28.      * 当主线程或子线程抛出异常时会调用exceptionHandler.handlerException(Thread thread, Throwable throwable) 
  29.      * 

     

  30.      * exceptionHandler.handlerException可能运行在非UI线程中。 
  31.      * 

     

  32.      * 若设置了Thread.setDefaultUncaughtExceptionHandler则可能无法捕获子线程异常。 
  33.      * 
  34.      * @param exceptionHandler 
  35.      */  
  36.     public static synchronized void install(ExceptionHandler exceptionHandler) {  
  37.         if (sInstalled) {  
  38.             return;  
  39.         }  
  40.         sInstalled = true;  
  41.         sExceptionHandler = exceptionHandler;  
  42.   
  43.         new Handler(Looper.getMainLooper()).post(new Runnable() {  
  44.             @Override  
  45.             public void run() {  
  46.   
  47.                 while (true) {  
  48.                     try {  
  49.                         Looper.loop();  
  50.                     } catch (Throwable e) {  
  51. //                        Binder.clearCallingIdentity();  
  52.                         if (e instanceof QuitCockroachException) {  
  53.                             return;  
  54.                         }  
  55.                         if (sExceptionHandler != null) {  
  56.                             //Unable to start activity  
  57.                             sExceptionHandler.handlerException(Looper.getMainLooper().getThread(), e);  
  58. //                            sUncaughtExceptionHandler.uncaughtException(Looper.getMainLooper().getThread(), e);  
  59.                         }  
  60.                     }  
  61.                 }  
  62.             }  
  63.         });  
  64.   
  65.         sUncaughtExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();  
  66.         Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {  
  67.             @Override  
  68.             public void uncaughtException(Thread t, Throwable e) {  
  69.                 if (sExceptionHandler != null) {  
  70.                     sExceptionHandler.handlerException(t, e);  
  71.                 }  
  72.             }  
  73.         });  
  74.   
  75.     }  
  76.   
  77.     public static synchronized void uninstall() {  
  78.         if (!sInstalled) {  
  79.             return;  
  80.         }  
  81.         sInstalled = false;  
  82.         sExceptionHandler = null;  
  83.         //卸载后恢复默认的异常处理逻辑,否则主线程再次抛出异常后将导致ANR,并且无法捕获到异常位置  
  84.         Thread.setDefaultUncaughtExceptionHandler(sUncaughtExceptionHandler);  
  85.         new Handler(Looper.getMainLooper()).post(new Runnable() {  
  86.             @Override  
  87.             public void run() {  
  88.                 throw new QuitCockroachException("Quit Cockroach.....");//主线程抛出异常,迫使 while (true) {}结束  
  89.             }  
  90.         });  
  91.   
  92.     }  
  93. }  

QuitCockroachException:

[java]  view plain  copy
  1. package com.support.framework.crash;  
  2.   
  3. /** 
  4.  * Created by wanjian on 2017/2/15. 
  5.  */  
  6.   
  7. final class QuitCockroachException extends RuntimeException {  
  8.     public QuitCockroachException(String message) {  
  9.         super(message);  
  10.     }  
  11. }  


你可能感兴趣的:(Android 全局异常捕获DefaultUncaughtExceptionHandler与Cockroach)