ThreadPoolExecutor配置及CompletableFuture使用

对ThreadPoolExecutor不了解的同学可以点下面链接先了解一下，后面我们直接进行使用

百度百科ThreadPoolExecutor介绍

第一步：创建一个SpringBoot工程（快速开始教程）

第二步：自定义ThreadExecutor构造方法

package com.example.config;

import java.util.concurrent.*;

/**
 * 1、线程池状态：
 *      五种状态：
 *          线程池的状态          说明
 *          RUNNING             允许提交并处理任务
 *          SHUTDOWN            不允许提交新的任务，但是会处理完已提交的任务
 *          STOP                不允许提交新的任务，也不会处理阻塞队列中未执行的任务，并设置正在执行的线程的中断标志位
 *          TIDYING             所有任务执行完毕，池中工作的线程数为0，等待执行terminated()勾子方法
 *          TERMINATED          terminated()勾子方法执行完毕
 *
 *      线程池的shutdown() 方法，将线程池由 RUNNING（运行状态）转换为 SHUTDOWN状态
 *      线程池的shutdownNow()方法，将线程池由RUNNING 或 SHUTDOWN 状态转换为 STOP 状态。
 *      注：SHUTDOWN 状态 和 STOP 状态 先会转变为 TIDYING 状态，最终都会变为 TERMINATED
 *
 * 2、ThreadPoolExecutor构造函数：
 *      ThreadPoolExecutor继承自AbstractExecutorService，而AbstractExecutorService实现了ExecutorService接口。
 *
 *      当调用线程池execute() 方法添加一个任务时，线程池会做如下判断：
 *          如果有空闲线程，则直接执行该任务；
 *          如果没有空闲线程，且当前运行的线程数少于corePoolSize，则创建新的线程执行该任务；
 *          如果没有空闲线程，且当前的线程数等于corePoolSize，同时阻塞队列未满，则将任务入队列，而不添加新的线程；
 *          如果没有空闲线程，且阻塞队列已满，同时池中的线程数小于maximumPoolSize ，则创建新的线程执行任务；
 *          如果没有空闲线程，且阻塞队列已满，同时池中的线程数等于maximumPoolSize ，则根据构造函数中的 handler 指定的策略来拒绝新的任务。
 *
 *      当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。
 *      注：如果线程池设置了allowCoreThreadTimeout参数为true（默认false），那么当空闲线程超过keepaliveTime后直接停掉。（不会判断线程数是否大于corePoolSize）即：最终线程数会变为0。
 *
 *      ThreadPoolExecutor线程池推荐了三种等待队列，它们是：SynchronousQueue 、LinkedBlockingQueue 和 ArrayBlockingQueue。
 *          1）有界队列：
 *              SynchronousQueue ：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于 阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法 Executors.newCachedThreadPool 使用了这个队列。
 *              ArrayBlockingQueue：一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。一旦创建了这样的缓存区，就不能再增加其容量。试图向已满队列中放入元素会导致操作受阻塞；试图从空队列中提取元素将导致类似阻塞。
 *          2）无界队列：
 *              LinkedBlockingQueue：基于链表结构的无界阻塞队列，它可以指定容量也可以不指定容量（实际上任何无限容量的队列/栈都是有容量的，这个容量就是Integer.MAX_VALUE）
 *              PriorityBlockingQueue：是一个按照优先级进行内部元素排序的无界阻塞队列。队列中的元素必须实现 Comparable 接口，这样才能通过实现compareTo()方法进行排序。优先级最高的元素将始终排在队列的头部；PriorityBlockingQueue 不会保证优先级一样的元素的排序。
 *          注意：keepAliveTime和maximumPoolSize及BlockingQueue的类型均有关系。如果BlockingQueue是无界的，那么永远不会触发maximumPoolSize，自然keepAliveTime也就没有了意义。
 *
 *      如果不指定线程工厂时，ThreadPoolExecutor 会使用ThreadPoolExecutor.defaultThreadFactory 创建线程。默认工厂创建的线程：同属于相同的线程组，具有同为 Thread.NORM_PRIORITY 的优先级，以及名为 “pool-XXX-thread-” 的线程名（XXX为创建线程时顺序序号），且创建的线程都是非守护进程。
 *
 *      handler ：表示当 workQueue 已满，且池中的线程数达到 maximumPoolSize 时，线程池拒绝添加新任务时采取的策略。（可以不指定）
 *                          策略                                                            说明
 *              ThreadPoolExecutor.AbortPolicy()                        抛出RejectedExecutionException异常。默认策略
 *              ThreadPoolExecutor.CallerRunsPolicy()                   由向线程池提交任务的线程来执行该任务
 *              ThreadPoolExecutor.DiscardPolicy()                      抛弃当前的任务
 *              ThreadPoolExecutor.DiscardOldestPolicy()                抛弃最旧的任务（最先提交而没有得到执行的任务）
 *
 *  3、常用方法：
 *      除了在创建线程池时指定上述参数的值外，还可在线程池创建以后通过如下方法进行设置。
 *          setCorePoolSize(int corePoolSize)                                       线程池中核心线程数的最大值
 *          setMaximumPoolSize(int maximumPoolSize)                                 线程池中能拥有最多线程数
 *          setKeepAliveTime(long time, TimeUnit unit)                              表示空闲线程的存活时间，表示keepAliveTime的单位
 *          allowCoreThreadTimeOut(boolean value)                                   设置策略，该策略控制在保持活动时间内没有任务到达时核心线程是否可以超时和终止，并在新任务到达时根据需要替换。如果为 false，则核心线程永远不会因缺少传入任务而终止。如果为 true，则应用于非核心线程的相同保持活动状态策略也适用于核心线程。为避免连续替换线程，设置 {@code true} 时保持活动时间必须大于零。通常，应在主动使用池之前调用此方法。@param值 {@code true} 如果应该超时，否则 {@code false} @throws IllegalArgumentException 如果值为 {@code true} 并且当前保持活动时间不大于零
 *          setThreadFactory(ThreadFactory threadFactory)                           用于缓存任务的阻塞队列，它决定了缓存任务的排队策略
 *          setRejectedExecutionHandler(RejectedExecutionHandler handler)           指定创建线程的工厂。（可以不指定）
 *
 *      此外，还有一些方法：
 *          getCorePoolSize()：返回线程池的核心线程数，这个值是一直不变的，返回在构造函数中设置的coreSize大小；
 *          getMaximumPoolSize()：返回线程池的最大线程数，这个值是一直不变的，返回在构造函数中设置的coreSize大小；
 *          getLargestPoolSize()：记录了曾经出现的最大线程个数（水位线）；
 *          getPoolSize()：线程池中当前线程的数量；
 *          getActiveCount()：Returns the approximate（近似） number of threads that are actively executing tasks；
 *          prestartAllCoreThreads()：会启动所有核心线程，无论是否有待执行的任务，线程池都会创建新的线程，直到池中线程数量达到 corePoolSize；
 *          prestartCoreThread()：会启动一个核心线程（同上）。
 *
 * 4、Executors类：
 *      Executors类的底层实现便是ThreadPoolExecutor！ Executors 工厂方法有：
 *          Executors.newCachedThreadPool()：无界线程池，可以进行自动线程回收
 *          Executors.newFixedThreadPool(int)：固定大小线程池
 *          Executors.newSingleThreadExecutor()：单个后台线程
 *          它们均为大多数使用场景预定义了设置。不过在阿里java文档中说明，尽量不要用该类创建线程池。
 *
 */
public class TestThreadExecutor extends ThreadPoolExecutor {

    /**
     * 创建线程执行器
     *
     * @param corePoolSize    线程池中核心线程数的最大值
     * @param maximumPoolSize 线程池中能拥有最多线程数
     * @param keepAliveTime   表示空闲线程的存活时间
     * @param unit            表示keepAliveTime的单位
     * @param workQueue       用于缓存任务的阻塞队列，它决定了缓存任务的排队策略
     * @param threadFactory   指定创建线程的工厂。（可以不指定）
     * @param handler         拒绝策略
     */
    public TestThreadExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        super(corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,
                threadFactory,
                handler);
    }
}

第三步：创建ThreadPoolExecutor，传入参数配置

package com.example.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@EnableAsync//开启异步支持
@Configuration
public class ThreadExecutorConfig {

    @Bean(name = "testThreadExecutor")
    public ThreadPoolExecutor threadPoolExecutor() {
        return new TestThreadExecutor(
                50,
                1000,
                60,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(10000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
    }
}

第四步：创建测试类测试

package com.example;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadPoolExecutor;

@Slf4j
@SpringBootTest
public class ThreadExecutorTest {

    @Autowired
    private ThreadPoolExecutor executor;

    @Test
    public void test01() {
        CompletableFuture.runAsync(() -> {
            log.info("进入异步任务执行");
            log.info(Thread.currentThread().getName());
            log.info("异步任务执行结束");
        }, executor);
    }
}

---------------------------------------------------------------------------------------------------------------------------------

CompletableFuture介绍：

        CompletableFuture 用于 Java 中的异步编程。异步编程是一种编写非阻塞代码的方法，方法是在与主应用程序线程不同的线程上运行任务，并通知主线程其进度、完成或失败。
        这样，您的主线程不会阻塞/等待任务的完成，它可以并行执行其他任务。拥有这种并行性极大地提高了程序的性能。

Future vs CompletableFuture

        CompletableFuture 是Java 8 中引入的 Java Future API的扩展。

        Future 用作对异步计算结果的引用。它提供了isDone()一种检查计算是否完成的get()方法，以及一种在计算完成时检索计算结果的方法。

        Future API 是向 Java 异步编程迈出的一大步，但它缺乏一些重要且有用的特性。

Future局限性

• 无法手动完成：

  假设您编写了一个接口来从远程 API 获取商品信息。由于此 API 调用非常耗时，因此您在单独的线程中运行它并从您的函数中返回一个 Future。

  现在，让我们假设，如果远程API服务关闭了，那么您希望根据商品的最后一次缓存价格手动完成Future。你能在Future上做到这一点吗?不!

• 你不能在没有阻塞的情况下对 Future 的结果执行进一步的操作：

  Future 不会通知你它的完成。它提供了一个阻塞get()方法，直到结果可用。

  您无法将回调函数附加到 Future 并在 Future 的结果可用时自动调用它。

• 多个Future不能链接在一起：

  有时您需要执行长时间运行的计算，当计算完成后，您需要将其结果发送到另一个长时间运行的计算，依此类推。

• 您不能将多个Future组合在一起：

  假设您有 10 个不同的 Futures 想要并行运行，然后在它们全部完成后运行某个函数。你不能用 Future 做到这一点。

• 无异常处理：

  Future API 没有任何异常处理结构。

CompletableFuture方法介绍：

未完待续......