在自定義線程池中捕獲和處理異常實(shí)現(xiàn)過程

更新時間：2026年05月14日 09:59:13 作者：北執(zhí)南念

這篇文章主要介紹了在自定義線程池中捕獲和處理異常實(shí)現(xiàn)過程,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教

1. MyUncaughtExceptionHandler 類

這是一個自定義的未捕獲異常處理器，當(dāng)線程因?yàn)槲床东@異常而終止時，就會調(diào)用這個處理器。它會記錄錯誤日志，并且可以添加像通知開發(fā)人員等額外的處理邏輯。

package com.hy.archive.config;

import lombok.extern.slf4j.Slf4j;

/**
 * Description: 自定義處理器
 *  這是一個自定義的未捕獲異常處理器，當(dāng)線程因?yàn)槲床东@異常而終止時，就會調(diào)用這個處理器。
 *
 * @Author Js
 * @Create 2025-07-08 20:04
 * @Version 1.0
 */
@Slf4j
public class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        log.error("Exception in thread :" + e);
        // do something
        //記錄日志、告警企業(yè)微信釘釘通知開發(fā)
    }
}

使用說明：一般不會直接調(diào)用這個類，而是通過線程工廠自動設(shè)置到線程上。

2. MyThreadFactory 類

這是一個自定義的線程工廠，其作用是對原生線程工廠進(jìn)行包裝。它會為每個新創(chuàng)建的線程設(shè)置一個自定義的未捕獲異常處理器，也就是MyUncaughtExceptionHandler。

package com.hy.archive.config;

import java.util.concurrent.ThreadFactory;

/**
 * Description: 自定義線程工廠處理
 *
 * @Author Js
 * @Create 2025-07-08 20:01
 * @Version 1.0
 */
public class MyThreadFactory implements ThreadFactory {

    private final ThreadFactory original;


    public MyThreadFactory(ThreadFactory original) {
        this.original = original;
    }


    @Override
    public Thread newThread(Runnable r) {
        Thread thread = original.newThread(r);
        // 異常捕獲
        thread.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());//自定義的未捕獲異常處理器
        return thread;
    }
}

使用說明：在配置線程池時，把這個工廠傳遞給線程池，這樣線程池創(chuàng)建的所有線程都會具備異常捕獲能力。

3. ThreadPoolConfig 類

這是一個 Spring 配置類，用于創(chuàng)建和配置一個名為accountExecutor的線程池。

package com.hy.archive.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 自定義單列線程池配置類
 */
@Configuration
@EnableAsync
public class ThreadPoolConfig implements AsyncConfigurer {

    //自定義線程池名稱
    public static final String ACCOUNT_EXECUTOR = "accountExecutor";

    @Override
    public Executor getAsyncExecutor() {
        return accountExecutor();
    }

    @Bean(ACCOUNT_EXECUTOR)
    @Primary
    public ThreadPoolTaskExecutor accountExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(500);
        // 線程池優(yōu)雅停機(jī)的關(guān)鍵
        executor.setWaitForTasksToCompleteOnShutdown(true);
        // 線程池前綴配置
        executor.setThreadNamePrefix("account-exec-");
        //滿了調(diào)用線程執(zhí)行，認(rèn)為重要任務(wù)
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //設(shè)置線程池的異常處理邏輯使用了裝飾器設(shè)計模式
        executor.setThreadFactory(new MyThreadFactory(executor));
        executor.initialize();
        return executor;

    }
}

4.舉個案例如何使用

1.異步使用

假設(shè)你有一個異步服務(wù)，使用該線程池執(zhí)行任務(wù)：

@Service
public class MyAsyncService {

    @Async("accountExecutor") // 指定使用自定義線程池
    public CompletableFuture<String> processAccount(String accountId) {
        // 模擬業(yè)務(wù)邏輯
        if (accountId == null) {
            throw new RuntimeException("賬戶ID不能為空"); // 未捕獲異常
        }
        // 正常業(yè)務(wù)邏輯...
        return CompletableFuture.completedFuture("處理完成");
    }
}

當(dāng)調(diào)用 processAccount(null) 時，會觸發(fā)未捕獲異常，此時異常處理流程如下：

線程池中的線程執(zhí)行任務(wù)時拋出 RuntimeException。
由于線程已通過 MyThreadFactory 設(shè)置了 MyUncaughtExceptionHandler，異常會被該處理器捕獲。
MyUncaughtExceptionHandler 記錄錯誤日志（例如：Exception in thread account-exec-1: 賬戶ID不能為空）。
可擴(kuò)展邏輯（如發(fā)送告警）被觸發(fā)。

2.結(jié)合 CompletableFuture

@Service
public class AccountService {

    @Autowired
    private ThreadPoolTaskExecutor accountExecutor; // 注入你的線程池

    public CompletableFuture<String> processAccount(String accountId) {
        return CompletableFuture.supplyAsync(() -> {
            // 模擬業(yè)務(wù)邏輯，可能拋出異常
            if (accountId == null) {
                throw new RuntimeException("賬戶ID不能為空");
            }
            // 正常處理邏輯...
            return "賬戶處理成功: " + accountId;
        }, accountExecutor) // 指定使用你的線程池
        .exceptionally(ex -> {
            // 處理異常的邏輯
            log.error("處理賬戶時發(fā)生異常: {}", ex.getMessage(), ex);
            return "處理失敗: " + ex.getMessage(); // 返回默認(rèn)值或錯誤信息
        });
    }
}

異常處理機(jī)制說明

supplyAsync + 指定線程池：

使用 accountExecutor 線程池執(zhí)行異步任務(wù)，該線程池已通過你的 MyThreadFactory 設(shè)置了 MyUncaughtExceptionHandler。

exceptionally 回調(diào)：

當(dāng)任務(wù)拋出異常時，exceptionally 會捕獲異常并返回默認(rèn)值或處理結(jié)果。這是 CompletableFuture 提供的顯式異常處理方式。

雙重保障：

若未使用 exceptionally，異常會被你的 MyUncaughtExceptionHandler 捕獲（記錄日志并觸發(fā)告警）。
若使用 exceptionally，異常會被顯式處理，同時 MyUncaughtExceptionHandler 仍會記錄日志（雙重保障）。

驗(yàn)證異常處理效果

@SpringBootTest
class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    void testExceptionHandling() throws Exception {
        // 模擬異常情況
        CompletableFuture<String> future = accountService.processAccount(null);
        
        // 驗(yàn)證異常處理結(jié)果
        String result = future.get(); // 不會拋出異常，因?yàn)閑xceptionally已處理
        assertEquals("處理失敗: 賬戶ID不能為空", result);
        
        // 檢查日志：MyUncaughtExceptionHandler也會記錄該異常
        // ERROR Exception in thread account-exec-1: 賬戶ID不能為空
    }
}

更復(fù)雜的異常處理鏈

CompletableFuture 提供了多種異常處理方法，可根據(jù)需求組合使用：

public CompletableFuture<String> processAccount(String accountId) {
    return CompletableFuture.supplyAsync(() -> {
        if (accountId == null) {
            throw new IllegalArgumentException("賬戶ID不能為空");
        }
        if (!isValid(accountId)) {
            throw new RuntimeException("賬戶ID無效");
        }
        return "賬戶處理成功: " + accountId;
    }, accountExecutor)
    .exceptionally(ex -> {
        if (ex instanceof IllegalArgumentException) {
            return "非法參數(shù): " + ex.getMessage();
        } else {
            return "系統(tǒng)錯誤: " + ex.getMessage();
        }
    })
    .thenApply(result -> {
        // 繼續(xù)處理結(jié)果
        return "最終結(jié)果: " + result;
    })
    .exceptionally(ex -> {
        // 處理后續(xù)步驟可能出現(xiàn)的異常
        return "處理失敗: " + ex.getMessage();
    });
}

關(guān)鍵區(qū)別：CompletableFuture vs 普通異步任務(wù)

場景	異常處理方式	是否需要 MyUncaughtExceptionHandler
普通異步任務(wù) (@Async)	依賴 MyUncaughtExceptionHandler 統(tǒng)一處理	必須配置
CompletableFuture + exceptionally	顯式捕獲并處理異常	可選（用于日志記錄和額外監(jiān)控）
CompletableFuture + 未處理異常	依賴 MyUncaughtExceptionHandler 捕獲	必須配置

最佳實(shí)踐建議

優(yōu)先使用 CompletableFuture 的顯式處理：

在異步任務(wù)中，盡量通過 exceptionally()、handle() 或 whenComplete() 顯式處理異常，使代碼更健壯。

保留統(tǒng)一異常處理器作為兜底：

你的 MyUncaughtExceptionHandler 仍有價值，可用于記錄所有未被顯式處理的異常，避免遺漏問題。

區(qū)分可恢復(fù)異常和不可恢復(fù)異常：

對不同類型的異常采取不同處理策略，例如：

.exceptionally(ex -> {
    if (ex instanceof RetryableException) {
        // 重試邏輯
        return retry(accountId);
    } else {
        // 記錄致命錯誤并返回默認(rèn)值
        log.error("致命錯誤", ex);
        return "默認(rèn)結(jié)果";
    }
})