Android 全局异常捕获DefaultUncaughtExceptionHandler与Cockroach

约定不等于承诺〃 2021-09-15 13:52 317阅读 0赞

# 前言 #

>     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][view plain]

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][view plain]

1.  Cockroach.uninstall();

测试

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

\[java\]  [view plain][]   [copy][view plain]

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][view plain]

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][view plain]

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][view plain]

1.  **for** (;;) \{  
2.           Message msg = queue.next(); // might block  
3.           ...  
4.           msg.target.dispatchMessage(msg);//执行Message  
5.           ...  
6.  \}

android消息机制伪代码如下：

\[java\]  [view plain][]   [copy][view plain]

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机制代码][java_Handler]

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

\[java\]  [view plain][]   [copy][view plain]

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][view plain]

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”][crash_Android]

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

下面贴出code:

Cockroach:

\[java\]  [view plain][]   [copy][view plain]

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.      \* <p> 
30.      \* exceptionHandler.handlerException可能运行在非UI线程中。 
31.      \* <p> 
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][view plain]

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. \}

[view plain]: https://blog.csdn.net/chenlove1/article/details/71423032#
[java_Handler]: https://android-notes.github.io/2016/12/03/5%E5%88%86%E9%92%9F%E5%AE%8C%E5%85%A8%E7%90%86%E8%A7%A3android-handler/
[crash_Android]: https://github.com/android-notes/Cockroach