spring boot 自定义线程池与使用

import cn.hutool.core.thread.ThreadFactoryBuilder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurerSupport;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import java.lang.reflect.Method;
import java.util.concurrent.Executor;
/**
 * 线程池配置(异步线程)
 */
@Slf4j
@Configuration
@EnableAsync
public class ThreadPoolTaskSchedulerConfig extends AsyncConfigurerSupport {
    @Bean("threadPoolTaskScheduler")
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        //这里使用的为定时任务线程池,替代@Scheduled注解,进行动态定时任务配置
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setThreadFactory(ThreadFactoryBuilder.create().build());
        scheduler.setPoolSize(60);
        scheduler.setRemoveOnCancelPolicy(true);
        scheduler.setThreadNamePrefix("TASK-SCHEDULE-");
        scheduler.initialize();
        return scheduler;
    }
    @Override
    public Executor getAsyncExecutor() {
        return threadPoolTaskScheduler();
    }
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (Throwable t, Method m, Object... args) -> {
            log.error("=============================" + t.getMessage() + "==============================");
            log.error("threadPoolTaskScheduler exception Method:" + m.getName());
        };
    }
}

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.stereotype.Component;
/**
 * @author lu_wanli
 **/
@Component
public class SpringHelper implements BeanFactoryPostProcessor, ApplicationContextAware {
    private static ConfigurableListableBeanFactory beanFactory;
    /**
     * 获取 Spring Bean工厂
     *
     * @return beanFactory
     */
    public static ConfigurableListableBeanFactory getBeanFactory() {
        return beanFactory;
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        SpringHelper.beanFactory = beanFactory;
    }
    /**
     * 获取指定name的bean
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException {
        return (T) beanFactory.getBean(name);
    }
    /**
     * 获取指定type的Bean
     */
    public static <T> T getBean(Class<T> clz) throws BeansException {
        return beanFactory.getBean(clz);
    }
    /**
     * 包含Bean
     *
     * @param name beanClassName
     * @return true/false
     */
    public static boolean containsBean(String name) {
        return beanFactory.containsBean(name);
    }
    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     *
     * @param name beanName
     * @return boolean
     */
    public static boolean isSingleton(String name) {
        return beanFactory.isSingleton(name);
    }
    private static ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringHelper.applicationContext = applicationContext;
    }
    /**
     * 动态注入单例bean实例
     *
     * @param beanName        bean名称
     * @param singletonObject 单例bean实例
     * @return 注入实例
     */
    public static Object registerSingletonBean(String beanName, Object singletonObject) {
        //将applicationContext转换为ConfigurableApplicationContext
        ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) applicationContext;
        //获取BeanFactory
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableApplicationContext.getAutowireCapableBeanFactory();
        //动态注册bean.
        defaultListableBeanFactory.registerSingleton(beanName, singletonObject);
        //获取动态注册的bean.
        return configurableApplicationContext.getBean(beanName);
    }
}

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
/**
 * 异步任务管理器
 *
 */
public class AsyncManager {
    /**
     * 异步操作任务调度线程池
     */
    private final ThreadPoolTaskExecutor taskExecutor = SpringHelper.getBean("threadPoolTaskExecutor");
    /**
     * 单例模式
     */
    private AsyncManager() {
    }
    private static final AsyncManager ME = new AsyncManager();
    public static AsyncManager me() {
        return ME;
    }
    /**
     * 执行任务
     *
     * @param task 任务
     */
    public void execute(Runnable task){
        taskExecutor.execute(task);
    }
    /**
     * 停止线程池
     */
    public void shutdown() {
        taskExecutor.shutdown();
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import javax.annotation.PreDestroy;
/**
 * 关闭线程池资源
 */
@Component
public class ShutDownManager {
    private static final Logger logger = LoggerFactory.getLogger(ShutDownManager.class);
    @PreDestroy
    public void destory() {
        shutdownAsyncManager();
    }
    private void shutdownAsyncManager() {
        try {
            logger.info("========关闭任务池==========");
            AsyncManager.me().shutdown();
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }
}