springboot中使用线程池实现异步调用

1.什么是线程池？

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。

2.常见的线程池

2.1 newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
这种类型的线程池特点是：
工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

2.2 newFixedThreadPool

创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。
FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

2.3 newSingleThreadExecutor

创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

2.4 newScheduleThreadPool

创建一个定长的线程池，而且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。

3.5 下图可见newScheduleThreadPool线程池是ThreadPoolExecutor的子类，所以本章将围绕ThreadPoolExecutor线程池去做详解。

ThreadPoolExecutor详解

进入ThreadPoolExecutor类中，可以看到，创建这个线程池，有四种方式，且全是有参构造。

查看全参构造

• corePoolSize：核心线程池大小
• maximumPoolSize：允许线程池同时并行的线程数量
• keepAliveTime：当线程数大于内核数时，这是多余的空闲线程将在终止之前等待新任务的最长时间
• unit：TimeUnit类型，这没什么好说
• workQueue：在执行任务之前用于保留任务的队列，此队列将仅保存execute方法提交的Runnable任务。
• threadFactory：执行程序创建新线程时要使用的工厂
• handler：当线等待队列中的数量超过既定容量，所需要处理策略

综上所述，我们做异步的话，不需要拒绝策略，所以，我们选择没有拒绝策略参数的构造方法去创建。

1.初始化线程池

@Component
public class ThreadPoolStarter {

    @Value("${thread-pool.corePoolSize:2}")
    private Integer corePoolSize;

    @Value("${thread-pool.maxPoolSize:3}")
    private Integer maximumPoolSize;

    @Value("${thread-pool.queueSize:10}")
    private Integer queueSize;

    @Value("${thread-pool.keepAliveTime:600}")
    private Long keepAliveTime;

    private TimeUnit unit = TimeUnit.SECONDS;

    @Bean("workerPool")
    public ThreadPoolExecutor threadPool() {
        // 线程工厂
        ThreadFactory threadFactory = new CustomizableThreadFactory("worker-pool-");
        // 初始化线程池
        return new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime,
                unit, new LinkedBlockingQueue<>(queueSize), threadFactory);
    }
}

2.创建线程类实现runnable接口

/**
 * @description
 * @author: yzr
 * @date: 2021-06-02 11:12
 **/
public class ThreadRunner implements Runnable {

    
    @Override
    public void run() {
        try {
            log.info("{}要睡眠了", Thread.currentThread().getName());
            Thread.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("{}执行了", Thread.currentThread().getName());
    }
}

3.测试,注入线程池，并把线程交由线程池去处理。

@SpringBootTest(classes = CasbinApplication.class)
@Slf4j
public class SpringBootTestTest {

    @Autowired
    private ThreadPoolExecutor threadPoolExecutor;

    @Autowired
    ThreadRunner threadRunner;

    @Test
    public void test() {
        log.info("{}开始了", Thread.currentThread().getName());
        threadPoolExecutor.execute(threadRunner);
        log.info("{}结束了", Thread.currentThread().getName());
    }

}

4.执行并查看结果

5.线程池最大线程池大小多少合适？

1.cpu密集型：cpu使用较高，充分利用主机cpu的资源，使得cpu的核数就是线程池的大小。

// java获取本机cpu的核数
Runtime.getRuntime().availableProcessors()

2.io密集型:cpu使用率较低，程序中会存在大量I/O操作占据时间，导致线程空余时间出来，所以通常就需要开cpu核数的两倍的线程。