使用静态内部类单例模式创建自定义线程池

一、使用场景

1、有时候业务上A端和B端做接口传输消息，B端收到消息后做进一步数据处理（持久化或者解析）等耗时的操作，如果是同步操作会造成等待、超时等情况。可以先向A端返回一个收到信息的消息，再多线程异步处理数据，处理完成之后根据业务需求向A端返回处理完成的信息。

二.静态内部类创建单例的好处

1.这个类的实例化是靠静态内部类的常量实例化的，只会加载一次赋值一次，随着静态内部类一起加载。

2.懒汉式、饿汉式有线程安全问题，需要加同步锁才能实现线程安全。才用静态内部类的话是线程安全的，理由同上。

三.自定义线程池的好处

我们都知道Java有4种线程池分别是：

1.newSingleThreadExecutor 单一的线程池

2.newFixedThreadPool 固定大小的线程池

3.newCachedThreadPool 自动扩大的线程池

4.newScheduledThreadPool 支持定时和周期性任务的线程池

但是都不建议使用，因为他们源码层面都是去调用ThreadPoolExecutor类，填充七个参数来执行的，所以更建议直接new一个ThreadPoolExecutor类，通过填充七大参数来实现自定义控制，更加明确线程池的运行规则，规避资源耗尽的风险。

 自定义线程ThreadPoolExecutor七大参数详解

1.corePoolSize：核心线程数

2.maximumPoolSize：线程池能够容纳的最大线程数

3.keepAliveTime：超时等待时间

4.timeUnit：时间单位

5.workqueue：等待进入线程池的任务缓存队列

6.threadFactory：线程执行工厂

7.handler：拒绝策略

其中拒绝策略又分为四种：

1.AbortPolicy：丢弃任务，并抛出异常，阻塞系统正常工作。

2.DiscardPolicy：丢弃无法处理的任务，不处理，不抛异常；允许任务丢失的话，是一种好策略。

3.DiscardOldestPolicy：丢弃队列最前面的任务，重新提交被拒绝的任务（喜新厌旧）

4.CallerRunsPolicy：只要线程池没关闭，直接在调用者线程中运行当前没丢弃的任务。对性能可能有影响

四、使用静态内部类单例模式创建线程池，并测试使用线程池里的线程异步处理消息

1.静态内部类创建线程池

public class SyncDataThreadPool {

    private static class SingletonHolder {
        /*使用自定义线程池，7个参数依次代表
            1、核心线程数
            2、最大线程数
            3、超时等待时间
            4、时间单位
            5、允许等待的线程数
            6、执行工厂
            7、拒绝策略（这里使用拒绝后续线程并抛异常的策略）
         */
        private static ExecutorService threadPool = new ThreadPoolExecutor(5,
                10,
                30,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(5),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
                );
    }

    public SyncDataThreadPool() {

    }

    public static ExecutorService newInstance() {
        return SingletonHolder.threadPool;
    }

2.编写业务代码，使用sleep模拟同步数据或者解析文件等比较耗时的操作

@ApiOperation(value = "测试", notes = "测试")
@PostMapping(value = "/test")
public String test(HttpServletRequest request , HttpServletResponse response) throws IOException {
    ExecutorService threadPool = SyncDataThreadPool.newInstance();
    log.info("当前线程池:"+threadPool.toString()+"它的hashcode为："+threadPool.hashCode());//通过toString和hashCode方法查看是否是同一个实例，保证单例
    threadPool.execute(new Runnable() {
        @Override
        public void run() {
            log.info("模拟解析文件开始，调用线程池的线程:"+Thread.currentThread().getName());//获取当前线程的名字
            try {
                Thread.sleep(10000);//模拟耗时的处理任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.info("模拟解析文件结束，调用线程池的线程:"+Thread.currentThread().getName());//获取当前线程的名字
            /**
             * 这里可以写回调A端的接口反馈消息
             * */
        }
    });

    log.info("-------------------返回认证方法了------------------------");
    return "ok";
}

 3.10秒内快速执行2次Controller方法之后的打印信息

可以看到，是同一个线程池（保证单例）里面两个不同的线程（多线程）异步执行了模拟持久化的操作，并且后面打印“返回认证方法了”在执行线程之前返回，实现了使用静态内部类单例模式创建线程池并异步执行的效果。