多任务之异步调用--线程池的应用

本文详细介绍自定义线程池的创建方式,包括定义常规线程池、实现AsyncConfigurer接口配置线程池以及自定义线程池配置类。探讨了线程池参数设置、线程工厂、队列类型及拒绝策略。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

线程池在日常开发过程中使用的频率还是很高的,在这里整理下自定义线程池的创建方式,原理方面就不赘述了。
1 常规线程池的定义

@Slf4j
public class NormalTreadPool {

    /**
     * 默认最大并发数以jvm可用处理器的数量的两倍
     */
    private static final int DEFAULT_MAX_CONCURRENT = Runtime.getRuntime().availableProcessors() * 2;
    /**
     * 线程池名称格式
     */
    private static final String THREAD_POOL_NAME = "NormalTreadPool-%d";
    /**
     * 线程工厂名称
     * 使用apache.lang3的线程工厂
     */
    private static final ThreadFactory FACTORY = new BasicThreadFactory.Builder().namingPattern(THREAD_POOL_NAME).daemon(true).build();
    /**
     * 默认队列大小
     */
    private static final int DEFAULT_SIZE = 500;
    /**
     * 默认线程存活时间
     */
    private static final long DEFAULT_KEEP_ALIVE = 60L;
    /**
     * Executor
     */
    private static ExecutorService executor;
    /**
     * 默认的拒绝策略
     * AbortPolicy:直接抛出异常阻止系统正常工作。
     * CallerRunsPolicy:只要线程池未关闭,该策略直接在调用者线程中,运行当前被丢弃的任务。
     * DiscardOldestPolicy:丢弃最老的一个请求,尝试再次提交当前任务。
     * DiscardPolicy:丢弃无法处理的任务,不给予任何处理。
     */
    private static final RejectedExecutionHandler defaultHandler = new ThreadPoolExecutor.AbortPolicy();
    /**
     * 执行队列
     * BlockingQueue<Runnable> workQueue = null;
     *     workQueue = new ArrayBlockingQueue<>(5);//基于数组的先进先出队列,有界
     *     workQueue = new LinkedBlockingQueue<>();//基于链表的先进先出队列,无界
     *     workQueue = new SynchronousQueue<>();//无缓冲的等待队列,无界
     *
     *     选择有界阻塞队列,避免队列中任务过于庞大
     */
    private static BlockingQueue<Runnable> executeQueue = new ArrayBlockingQueue<>(DEFAULT_SIZE);

    static {
        try {
            executor = new ThreadPoolExecutor(DEFAULT_MAX_CONCURRENT, DEFAULT_MAX_CONCURRENT * 4, DEFAULT_KEEP_ALIVE, TimeUnit.SECONDS, executeQueue, FACTORY, defaultHandler);
            // 关闭事件的挂钩
            Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
                @Override
                public void run() {
                    executor.shutdown();
                    try {
                        // 等待1秒执行关闭
                        if (!executor.awaitTermination(1, TimeUnit.SECONDS)) {
                            log.error("AsyncProcessor shutdown immediately due to wait timeout.");
                            executor.shutdownNow();
                        }
                    } catch (InterruptedException e) {
                        log.error("NormalTreadPool shutdown interrupted.");
                        executor.shutdownNow();
                    }
                    log.info("NormalTreadPool shutdown complete.");
                }
            }));
        } catch (Exception e) {
            log.error("NormalTreadPool init error.", e);
            throw new ExceptionInInitializerError(e);
        }

    }

    private NormalTreadPool() {
    }

    /**
     * 执行任务,不管是否成功<br>
     * 其实也就是包装以后的 方法
     *
     * @param task
     * @return
     */
    public static boolean executeTask(Runnable task) {
        try {
            executor.execute(task);
        } catch (RejectedExecutionException e) {
            log.error("Task executing was rejected.", e);
            return false;
        }
        return true;
    }

    /**
     * 提交任务,并可以在稍后获取其执行情况<br>
     * 当提交失败时,会抛出 {@link }
     *
     * @param task
     * @return
     */
    public static <T> Future<T> submitTask(Callable<T> task) {
        try {
            return executor.submit(task);
        } catch (RejectedExecutionException e) {
            log.error("Task executing was rejected.", e);
            throw new UnsupportedOperationException("Unable to submit the task, rejected.", e);
        }
    }
}

2 实现接口AsyncConfigurer,实现线程池
在springboot中提供了新的异步线程池的实现方式;配置类AsyncConfig,配置一个线程池,同时启动@Async注解,代码如下。

/**
 * 启动异步线程
 * 方法上有@Async注解的都将在这个线程池中执行
 */
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor(){
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.initialize();
        return taskExecutor;
    }

     @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new MyAsyncExceptionHandler();
    }

    class MyAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {

        @Override
        public void handleUncaughtException(Throwable throwable, Method method, Object... objects) {
            log.info("Exception message - " + throwable.getMessage());
            log.info("Method name - " + method.getName());
            for (Object param : objects) {
                log.info("Parameter value - " + param);
            }
        }
    }
}

配置成功后,带有@Async注解的方法都将驱动Spring异步执行,以上线程池的配置类中线程池的参数配置省略,可参考常规线程池中的配置;AsyncConfig这个配置类实现了SpringBoot提供的接口:

public interface AsyncConfigurer {
    @Nullable
    default Executor getAsyncExecutor() {
        return null;
    }

    @Nullable
    default AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return null;
    }
}

3 自定义线程池配置类
线程池的实例会通过spring自动注入,还有一种方式,可以不使用这个接口:

@Configuration
@EnableAsync
public class AsyncConfig {
    @Bean("taskExecutor")
    public Executor getAsyncExecutor(){
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.initialize();
        return taskExecutor;
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值