在自定义线程池中捕获和处理异常实现过程

package com.hy.archive.config;

import lombok.extern.slf4j.Slf4j;

/**
 * Description: 自定义处理器
 *  这是一个自定义的未捕获异常处理器，当线程因为未捕获异常而终止时，就会调用这个处理器。
 *
 * @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
        //记录日志、告警企业微信钉钉通知开发
    }
}

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;
    }
}

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);
        // 线程池优雅停机的关键
        executor.setWaitForTasksToCompleteOnShutdown(true);
        // 线程池前缀配置
        executor.setThreadNamePrefix("account-exec-");
        //满了调用线程执行，认为重要任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //设置线程池的异常处理逻辑使用了装饰器设计模式
        executor.setThreadFactory(new MyThreadFactory(executor));
        executor.initialize();
        return executor;

    }
}

@Service
public class MyAsyncService {

    @Async("accountExecutor") // 指定使用自定义线程池
    public CompletableFuture<String> processAccount(String accountId) {
        // 模拟业务逻辑
        if (accountId == null) {
            throw new RuntimeException("账户ID不能为空"); // 未捕获异常
        }
        // 正常业务逻辑...
        return CompletableFuture.completedFuture("处理完成");
    }
}

@Service
public class AccountService {

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

    public CompletableFuture<String> processAccount(String accountId) {
        return CompletableFuture.supplyAsync(() -> {
            // 模拟业务逻辑，可能抛出异常
            if (accountId == null) {
                throw new RuntimeException("账户ID不能为空");
            }
            // 正常处理逻辑...
            return "账户处理成功: " + accountId;
        }, accountExecutor) // 指定使用你的线程池
        .exceptionally(ex -> {
            // 处理异常的逻辑
            log.error("处理账户时发生异常: {}", ex.getMessage(), ex);
            return "处理失败: " + ex.getMessage(); // 返回默认值或错误信息
        });
    }
}

@SpringBootTest
class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    @Test
    void testExceptionHandling() throws Exception {
        // 模拟异常情况
        CompletableFuture<String> future = accountService.processAccount(null);
        
        // 验证异常处理结果
        String result = future.get(); // 不会抛出异常，因为exceptionally已处理
        assertEquals("处理失败: 账户ID不能为空", result);
        
        // 检查日志：MyUncaughtExceptionHandler也会记录该异常
        // ERROR Exception in thread account-exec-1: 账户ID不能为空
    }
}

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 "非法参数: " + ex.getMessage();
        } else {
            return "系统错误: " + ex.getMessage();
        }
    })
    .thenApply(result -> {
        // 继续处理结果
        return "最终结果: " + result;
    })
    .exceptionally(ex -> {
        // 处理后续步骤可能出现的异常
        return "处理失败: " + ex.getMessage();
    });
}

.exceptionally(ex -> {
    if (ex instanceof RetryableException) {
        // 重试逻辑
        return retry(accountId);
    } else {
        // 记录致命错误并返回默认值
        log.error("致命错误", ex);
        return "默认结果";
    }
})