详解线程池单例的使用

序言
Java为提升系统性能，经常采取线程池异步的方式，并发执行相同的业务逻辑；类似于Go的goroutine方式。同时，在Spring框架下做延迟加载，保证在使用的时候才真正初始化线程池，而不是在bean生成时候
但是，若初始化线程池时，没有注意单例问题，那每次使用线程池，都会创建出新的线程池。这会导致什么问题呢？由于线程池的核心线程数即使在没有任务执行时也会保留（线程处于waiting状态），长此以往，极易线程数量过多，引发系统OOM。

作者将按以下顺序梳理，读者可以按需观看

线程池单例的错误使用示范
定位线程池的使用错误
三种保证线程池单例的方案及验证
基于注解实现的异步线程池简介

1、线程池单例的错误使用方式

public class ThreadPoolTaskEasy {
    // 可抽取到配置文件中
    private static final String THREAD_NAME_PREFIX = "ThreadPoolExecutorTask-";

    RejectedExecutionHandler handler = new RejectedExecutionHandler() {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            log.error("task " + r.toString() + " reject from " + executor.toString());
        }
    };

    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor target = new ThreadPoolTaskExecutor();
        // 核心线程数设置为1
        target.setCorePoolSize(1);
        target.setMaxPoolSize(1);
        target.setQueueCapacity(2);
        target.setThreadNamePrefix(THREAD_NAME_PREFIX);
        target.setRejectedExecutionHandler(handler);
        target.initialize();
        log.info("ThreadPool:" + THREAD_NAME_PREFIX + " " + target.toString());
        return target;
    }

看一下Main方法的调用，启动整个SpringBoot工程，调用asyn2接口

@RequestMapping("/asyn2")
    public String asynTest2() {
        for(int i=0;i<10;i++){
            threadPoolTaskEasy.getAsyncExecutor().execute(new Runnable() {
                @Override
                public void run() {
                    CalculateService.add(1,2);
                }
            });
        }
        return "hello";
    }

2、如何定位线程池单例使用错误（jstack)

若线程池没有问题，使用Jstack打出线程堆栈，则预期是全局只有一个线程池，只有一个核心线程处于等待状态，但是出现了10个

3、三种保证线程池单例的方案，及验证

• 解决方案1：保证线程池单例，使用POSTCONSTRUCT初始化

public class ThreadPoolTaskEasy{
    // 可抽取到配置文件中
    private Integer capacity = 2;
    private static final String THREAD_NAME_PREFIX = "ThreadPoolExecutorTask-";

    private ThreadPoolTaskExecutor target = new ThreadPoolTaskExecutor();

    RejectedExecutionHandler handler = new RejectedExecutionHandler() {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            log.error("task " + r.toString() + " reject from " + executor.toString());
        }
    };
    // spring框架保证初始化一次，创建线程池，重点看这里
    @PostConstruct
    public void init() {
        target.setCorePoolSize(1);
        target.setMaxPoolSize(1);
        target.setQueueCapacity(2);
        target.setThreadNamePrefix(THREAD_NAME_PREFIX);
        target.setRejectedExecutionHandler(handler);
        target.initialize();
        log.info("ThreadPool:" + THREAD_NAME_PREFIX + " " + target.toString());
    }

    public Executor getAsyncExecutor() {
        return target;
    }
}

可以看出，调用/asyn2接口时候，只有一个核心线程，符合预期

• 解决方案2：使用构造函数进行初始化

public class ThreadPoolTask {
    // 可抽取到配置文件中
    private Integer capacity = 2;
    private ThreadPoolExecutor target;
    private static final String THREAD_NAME_PREFIX = "ThreadPoolTask-";

    // 指定队列
    LinkedBlockingQueue queue = new LinkedBlockingQueue(capacity);
    // 打印异常信息
    RejectedExecutionHandler handler = new RejectedExecutionHandler() {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            log.error("task " + r.toString() + " reject from " + executor.toString());
        }
    };
    // 修改线程池名称
    NamedThreadFactory namedThreadFactory = new NamedThreadFactory(THREAD_NAME_PREFIX);

    // 使用构造函数保证初始化一次，创建线程池
    public ThreadPoolTask() {
        target = new ThreadPoolExecutor(1, 1, 0L,
                TimeUnit.SECONDS, queue, namedThreadFactory, handler);
        log.info("ThreadPool:" + THREAD_NAME_PREFIX + " " + target.toString());
    }

    // 执行任务
    public void execute(Runnable runnable){
        target.submit(runnable);
    }


}

• 解决方案3：使用DCL做双重判定，延迟加载

@Service
@Slf4j
public class ThreadPoolTaskEasy{
    // 可抽取到配置文件中
    private static final String THREAD_NAME_PREFIX = "ThreadPoolExecutorTask-";

    private volatile ThreadPoolTaskExecutor target;

    RejectedExecutionHandler handler = new RejectedExecutionHandler() {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            log.error("task " + r.toString() + " reject from " + executor.toString());
        }
    };

    // 使用DCL做延迟加载
    public Executor getAsyncExecutor() {
        if (target == null) {
            synchronized (this) {
                if (target == null) {
                    target = new ThreadPoolTaskExecutor();
                    target.setCorePoolSize(1);
                    target.setMaxPoolSize(1);
                    target.setQueueCapacity(2);
                    target.setThreadNamePrefix(THREAD_NAME_PREFIX);
                    target.setRejectedExecutionHandler(handler);
                    target.initialize();
                    log.info("ThreadPool:" + THREAD_NAME_PREFIX + " " + target.toString());
                }
            }
        }
        return target;
    }
}

符合预期的一个线程池

4、扩展阅读

上述方案都是在显示的创建线程池，显示的调用线程执行，但spring5之后框架支持异步线程池，只需要做简单的注解配置，就能隐式的实现线程池的创建与调用
如何使用EnableSync/Async实现异步线程池?
主要分为

步骤	实现
一	设定线程池，实现AsyncConfigurer接口
二	在启动类上，注解@EnableAsync
三	在可以异步实现的方法上，注解@Async
四	愉快的使用

talk is easy ,show me the code

1. 设定线程池，实现AsyncConfigurer接口

public class ThreadPoolTaskSync  implements AsyncConfigurer {
    // 可抽取到配置文件中
    private static final String THREAD_NAME_PREFIX = "ThreadPoolAsync-";

    RejectedExecutionHandler handler = new RejectedExecutionHandler() {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            log.error("task " + r.toString() + " reject from " + executor.toString());
        }
    };

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor target = new ThreadPoolTaskExecutor();
        target.setCorePoolSize(3);
        target.setMaxPoolSize(3);
        target.setQueueCapacity(2);
        target.setThreadNamePrefix(THREAD_NAME_PREFIX);
        target.setRejectedExecutionHandler(handler);
        target.initialize();
        log.info("ThreadPoolAsync:" + THREAD_NAME_PREFIX + " " + target.toString());
        return target;
    }

}

2. 在启动类上，注解@EnableAsync

// 注意启动类上加上@EnableAsync，具体方法上加上@Async
@SpringBootApplication
@ServletComponentScan
@EnableAsync
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

3. 在可以异步实现的方法上，注解@Async

@Slf4j
@Component
public class CalculateService {
    public void step1() throws Exception{
        System.out.println("step1 begin");
        Thread.sleep(1000);
        System.out.println("step1 end");
    }

    @Async
    public void step2() throws Exception{
        System.out.println("step2 begin");
        Thread.sleep(1000);
        System.out.println("step2 end");
    }

    @Async
    public void step3() throws Exception{
        System.out.println("step3 begin");
        Thread.sleep(1000);
        System.out.println("step3 end");
    }

    // 获取返回值
    @Async
    public Future<String> step4(String s) throws Exception{
        System.out.println("step4 begin");
        Thread.sleep(1000);
        System.out.println("step4 end");
        return AsyncResult.forValue(s);
    }
}

4. 愉快的使用

@Test
    public void test2(){
        try{
            // 使用系统默认线程池
            calculateService.step1();
            // ThreadPoolAsync异步线程池
            calculateService.step2();
            // ThreadPoolAsync异步线程池
            calculateService.step3();
            // ThreadPoolAsync异步线程池
            calculateService.step4("huang").get();
        }catch (Exception e){}
    }

通过Debug可以看到三个线程都被启动了

看结果是step2与step3被同时执行的