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，数据却成功修改，可能导致错误。
