更多的相關的文章：http://www.cnblogs.com/lao-liang/p/5056176.html；(解釋了java中異常的一些分類）；http://www.cnblogs.com/freeliver54/archive/2011/10/17/2215423.html；（解釋瞭如何捕獲執行緒中出現的異常）

前言：由於執行緒中的本質特性，使得你不能捕獲從執行緒中逃逸的異常。一旦異常逃出任務的run()方法，它就會向外傳播，它就會向外傳播到控制檯，除非你採取特殊的步驟來捕獲這種錯誤的異常。在javaSE5之前，你可以使用執行緒組來捕獲這些異常。但是有了java SE5,就可以使用Executor來解決這個問題。因而你不需要了解有關執行緒組的任何的只是了。

   例如在下面的例子中，就會由於在run方法中，丟擲了異常，卻無法捕獲，從而導致了執行緒的停止執行。

總的來說，在java執行緒中，在run方法中，我們要在run()方法中，把一切的異常有處理掉，也就try-catch掉。不能讓這個執行緒丟擲異常，因為如果我們不使用特殊的方式的話，我們是無法捕獲從這個執行緒中逃逸的異常的。異常一旦丟擲了，那麼這個執行緒就會停止執行，但是不會影響主執行緒和其它的執行緒。因為主執行緒和其它的執行緒都不知道它丟擲了異常。

public class ExceptionThread implements  Runnable {
    @Override
public void 
 
run() {
        throw new RuntimeException();
}

    public static void main(String[] args) {
       Thread thread = new Thread(new ExceptionThread());
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(thread);
}
}

執行的結果為：

Exception in thread "pool-1-thread-1" java.lang.RuntimeException
at Concurrency.ExceptionThread.run(ExceptionThread.java:9)
at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
at java.lang.Thread.run(Unknown Source)

即使將main的主體放到try-catch語句塊中也是沒有用的。一樣會出現未捕獲的異常。

public static void main(String[] args) {
    try {
        Thread thread = new Thread(new ExceptionThread());
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(thread);
} catch (Exception e) {
        e.printStackTrace();
}
}

為了解決這個問題，我們要修改Executor中產生執行緒的方式。Thread.UnCaughtExecptionHandler是javaSE5中的新介面，它允許你為每一個Thread物件都附上一個異常處理器。比如像以下的這個例子：

class ExceptionThread2 implements  Runnable{
    @Override
public void run() {
        Thread t= Thread.currentThread();
System.out.println("run() by" + t);
System.out.println("eh=" + t.getUncaughtExceptionHandler());
        throw new RuntimeException();
}
}

class MyUncaughtExceptionHandler implements  Thread.UncaughtExceptionHandler{
    @Override
public void uncaughtException(Thread thread, Throwable ex) {
        System.out.println("caught" + ex);
}
}
//呼叫工廠化方法為每一個thread物件都附上一個未捕獲異常的處理器。
class HandlerThreadFactory implements ThreadFactory{
    @Override
public Thread newThread(Runnable r) {
        System.out.println(this + "creating new Thread");
Thread t = new Thread(r);
System.out.println("created " + t);
t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
System.out.println("eh=" + t.getUncaughtExceptionHandler());
        return t;
}
}
public class CaptureUncaughtException {
    public static void main(String[] args) {
        ExecutorService exec = Executors.newCachedThreadPool(new HandlerThreadFactory());
exec.execute(new ExceptionThread2());
}
}

[email protected] creating new Thread
created Thread[Thread-0,5,main]
[email protected]
run() byThread[Thread-0,5,main]
[email protected]
[email protected] creating new Thread
created Thread[Thread-1,5,main]
[email protected]
caughtjava.lang.RuntimeException

上面的示例使得你可以按照具體的情況逐個地設定處理器。如果你知道將要在程式碼中處處使用相同的異常處理器，那麼更加簡單的方式是在Thread類中設定一個靜態域，並將這個處理器設定為預設的未捕獲異常的處理器。比如像下面的例子：

public class SettingDefaultHandler{

 public static void main(String[] args){

   Thread.setDefaultUncaughtException(new MyUncaughtExceptionHandler());

ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new ExceptionThread());

 }

}

說明：這個處理器只有在不存線上程專有的未捕獲異常的情況下才會被呼叫。系統會檢查執行緒的專有的版本，如果沒有發現，則檢查執行緒組是有有其專有的uncaughtException()方法。如果也沒有，在呼叫defaultUncaughtExcept

   在java多執行緒程式中，所有執行緒都不允許丟擲未捕獲的checked exception（比如sleep時的InterruptedException），也就是說各個執行緒需要自己把自己的checked exception處理掉。這一點是通過java.lang.Runnable.run()方法宣告(因為此方法宣告上沒有throw exception部分)進行了約束。但是執行緒依然有可能丟擲unchecked exception（如執行時異常），當此類異常跑丟擲時，執行緒就會終結，而對於主執行緒和其他執行緒完全不受影響，且完全感知不到某個執行緒丟擲的異常(也是說完全無法catch到這個異常)。JVM的這種設計源自於這樣一種理念：“執行緒是獨立執行的程式碼片斷，執行緒的問題應該由執行緒自己來解決，而不要委託到外部。”基於這樣的設計理念，在Java中，執行緒方法的異常（無論是checked還是unchecked exception），都應該線上程程式碼邊界之內（run方法內）進行try catch並處理掉.換句話說，我們不能捕獲從執行緒中逃逸的異常。
看下面的例子：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExceptionThread implements Runnable {

    @Override
    public void run() {
        throw new RuntimeException("這個執行緒就幹了這麼一件事，丟擲一個執行時異常");
    }
    
    public static void main(String[] args) {
        try {
            ExecutorService exec = Executors.newCachedThreadPool();
            exec.execute(new ExceptionThread());
            System.out.println("該幹嘛幹嘛去");
        } catch (RuntimeException e) {
            System.out.println("能不能捕獲到異常？");
        }
        
    }

}

執行結果：

該幹嘛幹嘛去
Exception in thread "pool-1-thread-1" java.lang.RuntimeException: 這個執行緒就幹了這麼一件事，丟擲一個執行時異常
    at ExceptionThread.run(ExceptionThread.java:8)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
    at java.lang.Thread.run(Thread.java:619)

從執行結果中，我們可以看到的是，這個異常在main執行緒中沒有catch到，即

  System.out.println("能不能捕獲到異常？");

   永遠不會執行到。

        問題來了，我們如果需要捕獲其執行緒的unchecked異常時該怎麼辦？Java SE5之後，我們可以通過Executor來解決這個我問題。為了解決這個問題，我們需要修改Executor產生執行緒的方式。Thread.UncaughtExceptionHandler是java SE5中的新介面，它允許我們在每一個Thread物件上新增一個異常處理器。（UncaughtExceptionHandler）。Thread.UncaughtExceptionHandler.uncaughtException()方法會線上程因未捕獲的異常而面臨死亡時被呼叫。下面這個例子簡單的演示瞭如何使用UncaughtExceptionHandler

import java.lang.Thread.UncaughtExceptionHandler;

/**
 * 用於捕獲異常---捕獲的是uncheckedException
 * 
 * @author February30th
 * 
 */
public class MyUnchecckedExceptionhandler implements UncaughtExceptionHandler {

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("捕獲到異常：" + e);
    }

}

import java.util.concurrent.ThreadFactory;

public class HandlerThreadFactory implements ThreadFactory {

    @Override
    public Thread newThread(Runnable r) {
        System.out.println("建立一個新的執行緒");
        Thread t = new Thread(r);
        t.setUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());
        System.out.println("eh121 = " + t.getUncaughtExceptionHandler());
        return t;
    }

}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;


public class ThreadExceptionTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //下面有3中方式來執行執行緒。
        //第1種按照普通的方式。這是能捕獲到異常
        Thread t = new Thread(new ExceptionThread2());
        t.setUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());
        t.start();
        //第2種按照現成池，直接按照thread方式,此時不能捕獲到異常，為什麼呢？因為在下面程式碼中建立了一個執行緒，且設定了異常處理器，
        //但是呢，在我們執行緒池中會重設定新的Thread物件，而這個Thread物件沒有設定任何異常處理器，換句話說，我們線上程池外對執行緒做的
        //任何操作都是沒有用的
        ExecutorService exec1 = Executors.newCachedThreadPool();
        Runnable runnable = new ExceptionThread2();
        Thread t1 = new Thread(runnable);
        t1.setUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());
        exec1.execute(runnable);
        
        //第3種情況一樣的，也是走的執行緒池，但是呢是通過ThreadFactory方式，在ThreadFactory中會對執行緒做一些控制，可以設定異常處理器
        //此時是可以捕獲異常的。
        ExecutorService exec = Executors.newCachedThreadPool(new HandlerThreadFactory());
        exec.execute(new ExceptionThread2());
        
    }

}

執行結果

建立一個新的執行緒
eh121 = [email protected]
run() byThread[Thread-0,5,main]
eh=[email protected]
捕獲到異常：java.lang.RuntimeException: 丟擲執行時異常

從上述的執行結果中可以看到，未捕獲的異常是通過uncaughtException來捕獲的。

按照上述的例項，我們可以按照具體的情況，逐個地設定處理器。但是如果我們知道將要在程式碼的所有地方都是用相同的異常處理器，那麼更簡單的方式是在Thread類中設定一個靜態域，並將這個處理器設定為預設的未捕獲異常處理器。看下面的例子：

Thread.setDefaultUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());
        ExecutorService exec = Executors.newCachedThreadPool(new HandlerThreadFactory());
        exec.execute(new ExceptionThread2());

這個預設的處理器只有在執行緒不存在非預設的異常處理器時才會呼叫。 在執行時，系統會檢查執行緒是否有屬於自己的異常處理器，如果發現沒有，就去檢查相應的執行緒組是否有專有的異常處理器，如果發現也沒有，再呼叫預設的異常處理器。