线程池异常捕获

本文只做笔记

线程池的创建线程池

项目结构

maven依赖

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.8.RELEASE</version>
        <relativePath />
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8.1</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

ThreadUtils

package com.cn.util;

import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;

@Component
public class ThreadUtils {

    static Logger logger = LoggerFactory.getLogger(ThreadUtils.class);
    /**
     * 线程池维护线程的最少数量
     */
    private int corePoolSize = 10;
    /**
     * 线程池维护线程的最大数量
     */
    private int maxPoolSize = 50;
    /**
     * 缓存队列
     */
    private int queueCapacity = 100;
    /**
     * 允许的空闲时间
     */
    private int keepAlive = 60;

    //异步线程池
    @Bean(name = "asyncExceutor")
    public AsyncTaskExecutor asyncExceutor() {
        ThreadFactory threadFactory =  new BasicThreadFactory.Builder().uncaughtExceptionHandler(new MyThreadException()).build();
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setThreadFactory(threadFactory);
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setKeepAliveSeconds(keepAlive);
        executor.setQueueCapacity(queueCapacity);
        executor.setThreadNamePrefix("mqExecutor-");
        // rejection-policy：当pool已经达到max size的时候，如何处理新任务
        // CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行
        //对拒绝task的处理策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
    class MyThreadException implements Thread.UncaughtExceptionHandler{
        @Override
        public void uncaughtException(Thread t, Throwable e) {
            logger.error("myException"+ExceptionUtils.getStackTrace(e));
        }
    }
}

ThreaController

package com.cn.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("thread")
public class ThreaController {
    static Logger logger = LoggerFactory.getLogger(ThreaController.class);
    @Autowired
    private AsyncTaskExecutor asyncExceutor;
    @RequestMapping("/test")
    public void test(){
        asyncExceutor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("2222222222222222");
                int s = 1/0;
            }
        });
        System.out.println("111111111111111111");
    }
}

异常效果