2. 程式人生 > >處理Callable執行緒內部的非受檢異常

處理Callable執行緒內部的非受檢異常

阿新 • • 發佈：2018-12-05

之前的部落格中介紹過Runnable類執行緒的異常處理，資料JAVA多執行緒的童鞋應該知道。Java中處理Thread和Runnable執行緒體系之外，還用著名的Executor和Callable執行緒體系。而且，後者在實際中更為常見。那麼在Runnable中奏效的UncaughtExceptionHandler機制在Callable中時候仍然有效呢？我們用程式碼來驗證一下。


import java.util.concurrent.*;

public class Demo {
    private static final ExecutorService executorService = Executors.newSingleThreadExecutor();

    public static void main(String[] args) {
        Future<Integer> future = executorService.submit(new MyTask());
        try {
            System.out.println("myTask任務執行結果為" + future.get());
        } catch (InterruptedException e) {
            System.out.println("任務被中斷！");
        } catch (ExecutionException e) {
            System.out.println("任務內部丟擲未受檢異常！");
        } catch (CancellationException e){
            System.out.println("任務被取消！");
        }
        executorService.shutdown();
    }

    private static final class MyTask implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            Thread.currentThread().setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
                @Override
                public void uncaughtException(Thread t, Throwable e) {
                    System.out.println("unchecked exception happened:");
                    System.out.println(t.getId());
                    System.out.println(t.getName());
                    e.printStackTrace(System.out);
                }
            });
            int sum = 0;
            for (int i = 4; i >= 0; i--) {
                sum = sum + (12 / i);
            }
            return sum;
        }
    }

}

執行上面的程式發現，我們自定義的UncaughtExceptionHandler沒有生效。相反，Executor框架的異常捕獲機制倒是生效了。這說明Callable已經不再使用UncaughtExceptionHandler機制類處理非受檢異常了，而是使用它自己特有的機制。這一特有的機制是什麼呢？


線上程池中，執行緒池Executor會Catch住所有執行時異常，當使用Future.get()獲取其結果時，才會丟擲這些執行時異常。我們看Future類的get()方法就可見一斑。

    /**
     * Waits if necessary for the computation to complete, and then retrieves its result.
     * @return the computed result
     * @throws CancellationException if the computation was cancelled
     * @throws ExecutionException if the computation threw an exception
     * @throws InterruptedException if the current thread was interrupted while waiting
     */
    V get() throws InterruptedException, ExecutionException;
從JDK對Future.get()方法的定義可見：Callable執行緒中丟擲的非受檢異常會被Executor框架捕獲到，然後通過Future類的get()方法傳遞給呼叫者。get() 方法的ExecutionException異常就是Runnable執行緒或者Callable執行緒丟擲的異常。


那麼問題來了,使用Runnable結合Executor框架是否也是同樣的處理機制呢？還是說使用Runnable結合Executor就會使得UncaughtExceptionHandler生效呢？來看下面的程式碼：

import java.util.concurrent.*;
public class Demo {
    private static final ExecutorService executorService = Executors.newSingleThreadExecutor();

    public static void main(String[] args) {
        Future<?> future = executorService.submit(new MyTask());
        try {
            System.out.println("myTask任務執行結果為" + future.get());
        } catch (InterruptedException e) {
            System.out.println("任務被中斷！");
        } catch (ExecutionException e) {
            System.out.println("任務內部丟擲未受檢異常！");
        } catch (CancellationException e) {
            System.out.println("任務被取消！");
        }
        executorService.shutdown();
    }

    private static final class MyTask implements Runnable {
        @Override
        public void run() {
            Thread.currentThread().setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
                @Override
                public void uncaughtException(Thread t, Throwable e) {
                    System.out.println("unchecked exception happened:");
                    System.out.println(t.getId());
                    System.out.println(t.getName());
                    e.printStackTrace(System.out);
                }
            });
            int sum = 0;
            for (int i = 4; i >= 0; i--) {
                sum = sum + (12 / i);
            }
        }
    }
}

從程式執行的結果來看，Runnable結合Executor的情況下，仍然是和Callable的異常處理機制一樣。我們可以這樣總結： 當使用Executor執行緒池相關框架來執行執行緒任務時，UncaughtExceptionHandler執行緒異常處理機制就是不生效的，這種情況下，執行緒內部的異常由執行緒池框架統一管理。當程式呼叫Future類的get()方法時，將感知到執行緒內部的執行時異常。當程式不使用Future類獲取結果時，執行時異常將被執行緒池框架隱藏。看下面的程式碼： 
import java.util.concurrent.*;

public class Demo {
    private static final ExecutorService executorService = Executors.newSingleThreadExecutor();

    public static void main(String[] args) {
        executorService.submit(new MyTask());

        executorService.shutdown();
    }

    private static final class MyTask implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {

            int sum = 0;
            for (int i = 4; I >= 0; i--) {
                sum = sum + (12 / i);
            }
            return sum;
        }
    }
}

此程式後，在控制檯沒有任何輸出。 可見不使用future.get()的時候，執行時異常被執行緒池框架給“吃了”。

既然是由執行緒池框架統一管理，那麼是夠可以修改修改執行緒池框架的異常處理機制呢？答案是可以的。此時我們要自定義執行緒池框架，使用ThreadPoolExecutor類即可。ThreadPoolExecutor類提供了很多可調整的引數和鉤子函式，可以很方便的構造一個執行緒池。具體介紹參見筆者之前的部落格ThreadPoolExecutor執行緒池的使用。在這篇部落格中，介紹了一個afterExecute(Runnable, Throwable)方法，在該方法中可以定義當前執行緒池中執行的執行緒發生內部異常時的處理方案。例子如下：

import java.util.concurrent.*;
public class Demo {
    private static final ExecutorService executorService = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10)) {
        @Override
        protected void afterExecute(Runnable r, Throwable t) {
            super.afterExecute(r, t);
            printException(r, t);
        }

        private void printException(Runnable r, Throwable t) {

            if (t == null && r instanceof Future<?>) {
                try {
                    Object result = ((Future<?>) r).get();
                } catch (CancellationException ce) {
                    t = ce;
                } catch (ExecutionException ee) {
                    t = ee.getCause();
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt(); // ignore/reset
                }
            }
            if (t != null) {
                t.printStackTrace(System.out);
                executeTask();
            }
        }
    };


    public static void main(String[] args) throws InterruptedException {
        executeTask();
        executorService.awaitTermination(5, TimeUnit.SECONDS);
        executorService.shutdownNow();
    }

    private static void executeTask() {
        executorService.submit(new MyTask());
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static final class MyTask implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            int sum = 0;
            for (int i = 4; i >= 0; i--) {
                sum = sum + (12 / i);
            }
            return sum;
        }
    }
}

在上面的程式碼中，我們使用ThreadPoolExecutor類自定義了一個執行緒池物件，對於所有使用該執行緒池執行的任務，其異常都會通過afterExecute()方法捕獲到並進行處理。至此，關於Executor和Callable體系的執行緒內部執行時異常處理方案就介紹完了，你懂了嗎！



相關推薦

處理Callable執行緒內部的非受檢異常

之前的部落格中介紹過Runnable類執行緒的異常處理，資料JAVA多執行緒的童鞋應該知道。Java中處理Thread和Runnable執行緒體系之外，還用著名的Executor和Callable執行緒體系。而且，後者在實際中更為常見。那麼在Runnable中奏效的UncaughtExcepti

UncaughtExceptionHandler—處理Runnable執行緒內的非受檢異常

學過Java多執行緒的夥伴們都知道，Java入門的多執行緒方案就是Thread類和Runnable類。如下： public class Demo { public static void main(String[] args) { fun1();

java多執行緒的未捕獲異常處理機制

　一：為什麼要單獨講多執行緒的異常捕捉呢？ 先看個例子： public class ThreadException implements Runnable{ @Override public void run() { throw new RuntimeEx

Java中的執行緒通訊、執行緒組、未處理的執行緒異常

執行緒通訊 傳統的執行緒通訊 假設現在系統中有兩個執行緒，這兩個執行緒分別代表存款者和取錢者，而系統有一種特殊的要求，系統要求存款者和取錢者不斷地重複存款、取錢的動作，而且要求每當存款者將錢存入指定賬戶後，取錢者就立即取錢。不允許存款者和取錢者操作連續超過兩次。 為了實現這種功能

執行緒中不可控制異常的處理

1、異常 Exception：它指出了合理的應用程式想要捕獲的條件。 Exception又分為兩類：一種是CheckedException（非執行時異常），一種是UncheckedException（執行時異常）。這兩種Exception的區別主要是CheckedExce

java執行緒池中任務異常處理

首先我們看個例子，當使用執行緒池執行任務時如果某個任務出現異常會是什麼效果 import java.util.concurrent.SynchronousQueue; import java.util.concurrent.ThreadPoolExecut

主執行緒、守護執行緒、非守護執行緒

主執行緒 main，但不是守護執行緒。 守護執行緒 是指在程式執行的時候在後臺提供一種通用服務的執行緒。如gc。 非守護執行緒 也叫使用者執行緒，由使用者建立。 關係： 主執行緒和守護執行緒一起銷燬； 主執行緒和非守護執行緒互不影響。 例如： package

java多執行緒11.非阻塞同步機制

關於非阻塞演算法CAS。 比較並交換CAS：CAS包含了3個運算元---需要讀寫的記憶體位置V，進行比較的值A和擬寫入的新值B。當且僅當V的值等於A時，CAS才會通過原子的方式用新值B來更新V的值，否則不會執行任何操作。無論位置V的值是否等於A，都將返回V原有的值。然後執行緒可以基於新返回的V值來做對應的操作

Java受檢異常和非受檢異常

所有異常，都繼承自java.lang.Throwable類。 Throwable有兩個直接子類，Error類和Exception類。 Exception Exception則可使從任何標準Java庫的類方法，自己的方法以及執行時任何異常中丟擲來的基型別。 異常可分為執行異常（

java異常-受檢異常與非受檢異常

1.受檢異常 package com.cap3; public class Test1 { public static void main(String[] args) { //sql exception throw ne

java socket 服務端併發處理 與 執行緒池的使用

package yiwangzhibujian.threadserver; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.util.

多執行緒處理多執行緒網路程式設計問題

1、 一個伺服器，多個客戶端訪問。 2、多個伺服器多執行緒接收多個客戶端，但是埠號是固定的。 java 網路程式設計之TCP +多執行緒 + 執行緒池 資料： https://blog.csdn.net/tanghui270270/article/details/80603199

使用spring非同步請求處理以及執行緒池所帶來的坑以及利用visualvm監測執行緒及效能【草稿】

前言 在開始前，請先看看： 因為涉及到執行緒，估計肉眼是沒辦法觀測的了只能用工具了。 預設執行緒池的坑 非同步web開發專題及tomcat下的spring非同步請求配置勘誤 當你按照上文高高興興地配置好非同步支援然後想要開啟高併發的人生，我只能說你圖樣圖森破

（轉）Java中的守護執行緒 Java的守護執行緒與非守護執行緒

Java的守護執行緒與非守護執行緒   守護執行緒與非守護執行緒 最近在看多執行緒的Timer章節，發現運用到了守護執行緒，感覺Java的基礎知識還是需要補充。 Java分為兩種執行緒：使用者執行緒和守護執行緒 所謂守護執行緒是指在程式執行的時候在後臺提供一

java socket通訊I/O阻塞>多執行緒實現非阻塞通訊

簡單的java socket通訊，多個客戶端同時連線，功能可在此基礎上進行擴充套件。效果如圖： server： package com.lb.LB_Socket; import java.io.BufferedReader; import ja

如何防止後臺執行緒丟擲的異常讓程式崩潰退出

如果你的程式拋了異常，你是怎麼處理的呢？等待程式崩潰退出？還是進行補救？ 如果是做 UI 開發，很容易就找到 Dispatcher.UnhandledException 事件，然後在事件中進行補救。如果補救成功，可以設定 e.Handled = true 來阻

如何用java執行緒池做分批次查詢處理 java執行緒池ThreadPoolExecutor的使用

需求是在一個大資料量的表中按條件查詢出資料後做相應的業務。我是使用的java執行緒池ThreadPoolExecutor，實現分批次去查詢，查詢到資料後，又分多個執行緒去做業務。 執行緒池類為 java.util.concurrent.ThreadPoolExecutor，

Java多執行緒程式非阻塞式鎖定實現

           Java對多執行緒程式的鎖定已經有良好的支援，通常使用synchronized修飾一個方法或者一段程式碼。但是有一個問題，多個執行緒同時呼叫同一個方法的時候，所有執行緒都被排隊處理了。該被呼叫的方法越耗時，執行緒越多的時候，等待的執行緒等待的時間也就越

Python並行處理——多執行緒

Parallel Processing 並行處理利用多個CPU在同一時間處理多條指令，這是個很有用的技術，但是它帶來的問題也是很多的，比如多個處理器怎麼共享資料？這個會造成很多讀寫衝突，因此需要

Java的守護執行緒和非守護執行緒

一、守護執行緒         java分為兩種執行緒：使用者執行緒和守護執行緒         守護執行緒是指在程式執行的時候在後臺提供一種通用服務的執行緒，比如垃圾回收執行緒就是一個很稱職的守護者，並且這種執