Java中捕獲線程異常的方式有哪些

這篇文章主要介紹“Java中捕獲線程異常的方式有哪些”，在日常操作中，相信很多人在Java中捕獲線程異常的方式有哪些問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Java中捕獲線程異常的方式有哪些”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

首先，我們要知道，在Java中，線程中的異常是不能拋出到調用該線程的外部方法中捕獲的。

為什么不能拋出到外部線程捕獲？

因為線程是獨立執行的代碼片斷，線程的問題應該由線程自己來解決，而不要委托到外部。

基于這樣的設計理念，在Java中，線程方法的異常都應該在線程代碼邊界之內（run方法內）進行try catch并處理掉。

換句話說，我們不能捕獲從線程中逃逸的異常。

怎么進行的限制？

通過java.lang.Runnable.run()方法聲明(因為此方法聲明上沒有throw exception部分)進行了約束。

如果在線程中拋出了線程會怎么樣？

線程會立即終結。

現在我們可以怎樣捕獲線程中的異常？

Java中在處理異常的時候，通常的做法是使用try-catch-finally來包含代碼塊，但是Java自身還有一種方式可以處理——使用UncaughtExceptionHandler。

它能檢測出某個線程由于未捕獲的異常而終結的情況。

當一個線程由于未捕獲異常而退出時，JVM會把這個事件報告給應用程序提供的UncaughtExceptionHandler異常處理器（這是Thread類中的接口）：

//Thread類中的接口
public interface UncaughtExceptionHanlder {
    void uncaughtException(Thread t, Throwable e);
}

JDK5之后允許我們在每一個Thread對象上添加一個異常處理器UncaughtExceptionHandler 。

Thread.UncaughtExceptionHandler.uncaughtException()方法會在線程因未捕獲的異常而面臨死亡時被調用。

首先要先定義一個異常捕獲器：

public class MyUnchecckedExceptionhandler implements UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("捕獲異常處理方法：" + e);
    }
}

方法1. 創建線程時設置異常處理Handler

Thread t = new Thread(new ExceptionThread());
t.setUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());
t.start();

方法2. 使用Executors創建線程時，還可以在ThreadFactory中設置

ExecutorService exec = Executors.newCachedThreadPool(new ThreadFactory(){
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());
                return thread;
            }
});
exec.execute(new ExceptionThread());

不過，上面的結果能證明：通過execute方式提交的任務，能將它拋出的異常交給異常處理器。

如果改成submit方式提交任務，則異常不能被異常處理器捕獲，這是為什么呢？

查看源碼后可以發現，如果一個由submit提交的任務由于拋出了異常而結束，那么這個異常將被Future.get封裝在ExecutionException中重新拋出。

所以，通過submit提交到線程池的任務，無論是拋出的未檢查異常還是已檢查異常，都將被認為是任務返回狀態的一部分，因此不會交由異常處理器來處理。

java.util.concurrent.FutureTask 源碼

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)//如果任務沒有結束，則等待結束
        s = awaitDone(false, 0L);
    return report(s);//如果執行結束，則報告執行結果
}

@SuppressWarnings("unchecked")
private V report(int s) throws ExecutionException {
    Object x = outcome;
    if (s == NORMAL)//如果執行正常，則返回結果
        return (V)x;
    if (s >= CANCELLED)//如果任務被取消，調用get則報CancellationException
        throw new CancellationException();
    throw new ExecutionException((Throwable)x);//執行異常，則拋出ExecutionException
}

方法3. 使用線程組ThreadGroup

//1.創建線程組
ThreadGroup threadGroup =
        // 這是匿名類寫法
        new ThreadGroup("group") {
            // 繼承ThreadGroup并重新定義以下方法
            // 在線程成員拋出unchecked exception 會執行此方法
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                //4.處理捕獲的線程異常
            }
        };
//2.創建Thread        
Thread thread = new Thread(threadGroup, new Runnable() {
    @Override
    public void run() {
        System.out.println(1 / 0);

    }
}, "my_thread");  
//3.啟動線程
thread.start();

方法4. 默認的線程異常捕獲器

如果我們只需要一個線程異常處理器處理線程的異常，那么我們可以設置一個默認的線程異常處理器，當線程出現異常時，

如果我們沒有指定線程的異常處理器，而且線程組也沒有設置，那么就會使用默認的線程異常處理器

// 設置默認的線程異常捕獲處理器
Thread.setDefaultUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());

上面說的4種方法都是基于線程異常處理器實現的，接下來將的幾種方法則不需要依賴異常處理器。

方法5. 使用FetureTask來捕獲異常

//1.創建FeatureTask
FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
        return 1/0;
    }
});
//2.創建Thread
Thread thread = new Thread(futureTask);
//3.啟動線程
thread.start();
try {
    Integer result = futureTask.get();
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    //4.處理捕獲的線程異常
}

方法6.利用線程池提交線程時返回的Feature引用

//1.創建線程池
ExecutorService executorService = Executors.newFixedThreadPool(10);
//2.創建Callable，有返回值的，你也可以創建一個線程實現Callable接口。
//  如果你不需要返回值，這里也可以創建一個Thread即可，在第3步時submit這個thread。
Callable<Integer> callable = new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
        return 1/0;
    }
};
//3.提交待執行的線程
Future<Integer> future = executorService.submit(callable);
try {
     Integer result = future.get();
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    //4.處理捕獲的線程異常
}

實現原理可以看一下方法2的說明。

方法6本質上和方法5一樣是基于FutureTask實現的。

方法7.重寫ThreadPoolExecutor的afterExecute方法

//1.創建線程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MILLISECONDS,
        new LinkedBlockingQueue<>()) {
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        if (r instanceof Thread) {
            if (t != null) {
                //處理捕獲的異常
            }
        } else if (r instanceof FutureTask) {
            FutureTask futureTask = (FutureTask) r;
            try {
                futureTask.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                //處理捕獲的異常
            }
        }

    }
};


Thread t1 = new Thread(() -> {
    int c = 1 / 0;
});
threadPoolExecutor.execute(t1);

Callable<Integer> callable = () -> 2 / 0;
threadPoolExecutor.submit(callable);

到此，關于“Java中捕獲線程異常的方式有哪些”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！