8、ThreadPoolTaskExecutor线程并发

一、线程池的优点：

1、降低资源消耗。通过重复利用自己创建的线程降低线程创建和销毁造成的消耗。

2、提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

3、提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗资源，还会降低系统的稳定性，使用线程池可以进行统一分配，调优和监控。

二、ThreadPoolTaskExecutor实现线程并发：

相关参考

ThreadPoolTaskExecutor是spring core包中的，而ThreadPoolExecutor是JDK中的JUC。ThreadPoolTaskExecutor是对ThreadPoolExecutor进行了封装处理。

1、声明ThreadPoolTaskExecutor线程池配置：

@Configuration
public class TaskPoolConfig {
    /**
     * ThreadPoolTaskExecutor是spring core包中的，而ThreadPoolExecutor是JDK中的JUC。
     * ThreadPoolTaskExecutor是对ThreadPoolExecutor进行了封装处理。
     *
     * 拒绝策略：
     * （1）、CallerRunsPolicy: 当触发拒绝策略，只要线程池没有关闭的话，则使用调用 线程直接运行任务。一般并发比较小，性能要求不高，不允许失败。
     * 　　　　但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大
     * （2）、AbortPolicy: 丢弃任务，并抛出拒绝执行
     * （3）、RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行。
     * （4）、DiscardPolicy: 直接丢弃，其他啥都没有
     * （5）、DiscardOldestPolicy: 当触发拒绝策略，只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入
     */
    @Value("${async.thread.concurrency.coreSize:10}")
    private int coreSize;

    @Value("${async.thread.concurrency.maxSize:20}")
    private int maxSize;

    @Value("${async.thread.concurrency.queueCapacity:1000}")
    private int queueCapacity;

    @Value("${async.thread.concurrency.keepAliveSeconds:10000}")
    private int keepAliveSeconds;

    @Bean
    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
        final ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(coreSize); //核心线程数
        executor.setMaxPoolSize(maxSize);   //最大线程数
        executor.setQueueCapacity(queueCapacity);   //最大等待队列数
        executor.setKeepAliveSeconds(keepAliveSeconds); //除核心线程，其他线程的保留时间
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());    //等待队列满后的拒绝策略
        executor.initialize();  //执行初始化
        executor.setThreadNamePrefix("async-executor-");    //线程前缀名称
        return executor;
    }
}

2、业务类：

（1）、

@Service
@Slf4j
public class ThreadConcurrencyServiceImpl implements ThreadConcurrencyService {
    @Autowired
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;  //线程池配置声明

    @Autowired
    private GetCountData getCountData;

    @Override
    public List<ThreadConcurrencyVO> getCountNum() {
        StopWatch stopWatch = new StopWatch("ThreadPoolTaskExecutor多线程方式执行任务");
        stopWatch.start();
        log.info("====================ThreadPoolTaskExecutor多线程方式执行任务开始========================");

        List<ThreadConcurrencyVO> list = getListData();

        stopWatch.stop();
        log.info("====================ThreadPoolTaskExecutor多线程方式执行任务结束========================");
        log.info(stopWatch.prettyPrint());
        return list;
    }

//========================================业务逻辑==================================
    /**
     * 多线程方式
     * */
    private List<ThreadConcurrencyVO> getListData(){
        List<ThreadConcurrencyVO> list = new ArrayList<>();

        //获取一间教室下数据的线程
        Integer testNumOne = 0;
        Double avgGradeOne = 0.0;
        log.info("线程一执行");
        Callable<Map<String, QueryVO>> oneRoomData = () -> getCountData.getData(1);
        Future<Map<String, QueryVO>> oneRoomFuture = threadPoolTaskExecutor.submit(oneRoomData);

        //获取二间教室下数据的线程
        Integer testNumTwo = 0;
        Double avgGradeTwo = 0.0;
        log.info("线程二执行");
        Callable<Map<String, QueryVO>> twoRoomData = () -> getCountData.getData(2);
        Future<Map<String, QueryVO>> twoRoomFuture = threadPoolTaskExecutor.submit(twoRoomData);

        try {
            //获取一间教室下数据
            Map<String, QueryVO> oneRoomMap = oneRoomFuture.get();
            testNumOne = oneRoomMap.get("testCount").getTestNum();
            avgGradeOne = oneRoomMap.get("testCount").getAvgGrade();
            //获取二间教室下数据
            Map<String, QueryVO> twoRoomMap = twoRoomFuture.get();
            testNumTwo = twoRoomMap.get("testCount").getTestNum();
            avgGradeTwo = twoRoomMap.get("testCount").getAvgGrade();

            //List集合返回数据
            ThreadConcurrencyVO threadConcurrencyVO1 = ThreadConcurrencyVO.builder()
                    .uuid(UUID.randomUUID().toString())
                    .name("ONE")
                    .testNum(testNumOne)
                    .avgGrade(avgGradeOne)
                    .build();
            ThreadConcurrencyVO threadConcurrencyVO2 = ThreadConcurrencyVO.builder()
                    .uuid(UUID.randomUUID().toString())
                    .name("TWO")
                    .testNum(testNumTwo)
                    .avgGrade(avgGradeTwo)
                    .build();
            list.add(threadConcurrencyVO1);
            list.add(threadConcurrencyVO2);

        } catch (InterruptedException e) {
            log.info("线程中断异常：{}", e.getMessage());
        } catch (ExecutionException e) {
            log.info("线程执行异常：{}", e.getMessage());
        }
        log.info("返回结果："+list);
        return list;
    }
}

（2）、

    @Override
    public Map<String, QueryVO> getData(Integer room) {
        Map<String, QueryVO> mapData = new HashMap<>();

        //Atomic家族(事务的四个特性ACID，其中A就是原子性)主要是保证多线程环境下的原子性(指一个操作是不可中断的,同时成功，同时失败)，相比synchronized而言更加轻量级
        AtomicInteger testNum = new AtomicInteger(0);
        AtomicReference<Double> avgGrade = new AtomicReference<>(0.0);

        Integer num = 0;
        double avg = 0.0;
        for (int i = 0; i < room * 30; i++) {
            num++;
        }
        avg = num / (num + 1000.0);
        //统计测试人数
        testNum.set(num);
        //计算占比值
        avgGrade.set(avg);

        QueryVO queryVO = QueryVO.builder()
                .testNum(testNum.get())
                .avgGrade(avgGrade.get())
                .build();
        mapData.put("testCount", queryVO);

        return mapData;
    }

三、线程池底层工作原理：

1、在创建了线程池后，等待提交过来的任务请求。

2、当调用execute()方法添加一个请求任务时，线程池会做如下判断：

　　（1）、如果正在运行的线程数量小于corePoolSize（线程池的核心线程数），那么马上创建线程运行这个任务；

　　（2）、如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入workQueue阻塞队列中；

　　（3）、如果这时候workQueue阻塞队列饱和且正在运行的线程数量还小于 maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；

　　（4）、如果workQueue 阻塞队列满了且正在运行的线程数量大于或等于 maximumPoolSize（即：workQueue.size() + maximumPoolSize），那么线程池会启动饱和拒绝策略来执行。

3、当一个线程完成任务时，它会从workQueue 阻塞队列中取下一个任务来执行。

4、当一个线程无事可做，超过一定的时间(keepAliveTime) 时，线程池会判断：

　　如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

四、Thread类、Runnable接口与Callable接口的区别：

1、实现 Runnable 接口相比继承 Thread 类的优势：

（1）、可以避免由于 Java 的单继承特性而带来的局限

（2）、增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的

（3）、线程池只能放入实现 Runable 或 Callable 类线程，不能直接放入继承 Thread 的类

2、实现 Runnable 接口和实现 Callable 接口的区别：

（1）、Runnable 是自从 java1.1 就有了，而 Callable 是 1.5 之后才加上去的

（2）、实现 Callable 接口的任务线程能返回执行结果，而实现 Runnable 接口的任务线程不能返回结果

（3）、Callable 接口的 call()方法允许抛出异常，而 Runnable 接口的 run()方法的异常只能在内部消化，不能继续上抛

（4）、加入线程池运行，Runnable 使用 ExecutorService 的 execute 方法，Callable 使用 submit 方法

注：Callable 接口支持返回执行结果，此时需要调用 FutureTask.get()方法实现，此方法会阻塞主线程直到获取返回结果，当不调用此方法时，主线程不会阻塞

五、Future接口与FutureTask类获取Callable线程的返回结果详解：

在并发编程中，我们经常用到非阻塞的模型，在多线程的三种实现方式中，不管是继承Thread类还是实现Runnable接口，都无法保证获取到之前的执行结果。而使用Callable接口创建线程，需要实现call（）方法，call（）在完成时返回结果必须存储在主线程已知的对象中，可以使用Future接口或FutureTask类获取该线程的返回结果。

源码：get()用于获取任务的结果

public Object get（）throws InterruptedException，ExecutionException；

1、Future对象可以在后台完成主线程中比较耗时的操作，但不会导致主线程阻塞，当主线程将来需要其执行结果时，可通过Future对象获得后台作业的计算结果或者执行状态。

2、FutureTask多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果

3、Future对象或FutureTask对象调用get（）方法获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，一旦计算完成，就不能再重新开始或取消计算，只会返回结果或者抛出异常。

六、线程池中submit()和execute()方法的区别：

1、execute()：只能执行Runnable 类型的任务。

2、submit()：可以执行Runnable和Callable类型的任务。

Callable 类型的任务可以获取执行的返回值，而Runnable执行无返回值。

七、多线程之Atomic原子类：

1、Atomic原子类：

Atomic (事务的四个特性ACID，其中A就是原子性) 指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。所以，所谓原子类说简单点就是具有原子/原子操作特征的类。

原子类存放在java.util.concurrent.atomic下：

2、实现原理：

Atomic类主要利用CAS (Compare And Swap)算法、volatile变量与native方法来保证原子操作，从而避免synchronized的高开销，执行效率大为提升。

八、多线程中的CAS算法：

1、CAS算法的理解：

（1）、CAS（Compare And Swap），即比较再替换。JDK5之前Java语言是靠synchronized关键字保证同步的，这是一种独占锁，也是悲观锁。JDK5增加了并发包java.util.concurrent.*，该类下采用CAS算法实现，CAS算法是一种区别于synchronouse同步锁的乐观锁。

（2）、CAS操作包含三个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，才将内存值V修改为B并返回true，否则什么都不做并返回false（需要volatile变量配合）

2、CAS算法存在的问题：

（1）、CPU开销较大

（2）、不能保证代码块的原子性

（3）、ABA问题（最大问题）

ABA问题，即并发环境下，并发1在修改数据时，虽然还是A，但已经不是初始条件的A了，中间发生了A变B，B又变A的变化，此A已经非彼A，数据却成功修改，可能导致错误。

搜索

复制