Java多线程学习（七）
1.为什么要使用线程池
线程池优势:线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了线程池的最大线程数量，超出数量的线程排队等候，等其他线程执行完成后，再从队列中取出任务来执行。
它的主要特点是：线程复用，控制最大并发数，管理线程。
降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
提高响应速度。当任务到达时，任务可以不需要等待线程创建就可尽快执行。
提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
2. 线程池的使用
1.架构图，Executor，Executors，ExecutorService，ThreadPoolExecutor
2.构造方法
执行长期任务性能好，创建一个线程池，一池拥有n个固定的线程，有固定线程数的线程池
ExecutorService executorService = Executors.newFixedThreadPool(int n);
一池拥有1个固定的线程，任务一个一个地执行
ExecutorService executorService = Executors.newSingleThreadExecutor();
执行很多短期异步任务，线程池根据需要创建新线程，但再先前构建的线程可以时将重用它们，可扩容。
ExecutorService executorService2 = Executors.newCachedThreadPool();
上述三个构造方法分别对应：
（1）
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }
（2）
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); }
（3）
public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); }
3.线程池的七大参数
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0) throw new IllegalArgumentException(); if (workQueue == null || threadFactory == null || handler == null) throw new NullPointerException(); this.acc = System.getSecurityManager() == null ? null : AccessController.getContext(); this.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; }
corePoolSize 线程池中的常驻核心线程数
maximumPoolSize 线程池中能容纳同时执行的最大线程数，此值必须大于等于1
keepAliveTime 多余的空闲线程的存活时间，当前线程池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余线程会被销毁直到只剩下corePoolSize个线程位置
unit keepAliveTime的参数
workQueue 任务队列（阻塞队列，相当于候客区），被提交但尚未被执行的任务，控制了线程的并发数
threadFactory 表示生产线程池中工作线程的线程工厂，用于创建线程，一般默认即可
handler 拒绝策略，表示当队列满了，并且工作线程大于等于线程池的最大线程数时，如何来拒绝请求执行的Runnable的策略
4.线程池的底层工作原理
结合自己的理解，我画了一个这样的流程图：
（1）创建了线程池后，开始等待请求
（2）当调用execute()方法添加一个请求任务时，线程池会做如下判断：
如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；
如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务加入到阻塞队列中；
如果阻塞队列满了，且正在运行的线程数量还小于maximumPoolSize，那么线程池会创建非核心线程来离立刻执行这个任务；
如果队列满了，且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动拒绝策略来拒绝任务；
（3）当一个线程完成任务时，它会从队列中获取下一个任务来执行
（4）当一个线程空闲，且超过了keepAliveTime时，线程池会判断：
如果当前运行的线程数大于corePoolSize，那么这些空闲线程会被停止
如果线程池的所有任务完成后，线程池中的线程都会收缩到corePoolSize的大小。
5.线程池中如何设置合理参数
1.使用哪种线程池？其实是一个也不用，而是自己手写。
2.自定义一个线程池
package com.Zhongger.Day08; import java.util.concurrent.*; /** * @Author Zhongger * @Description 线程池 * @Date 20203.3 */ public class ExecutorTest { public static void main(String[] args) { ExecutorService executorService = new ThreadPoolExecutor( 2, 5, 2L, TimeUnit.SECONDS, new LinkedBlockingDeque<>(3), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy()); for (int i = 0; i < 8; i++) { executorService.execute(()->{ System.out.println(Thread.currentThread().getName()+"\t 执行任务"); }); } } }
上述自定义线程池中：
corePoolSize=2 即核心线程数为2
maximumPoolSize=5 即最大线程数为5，能够容纳的线程数为5
keepAliveTime=2L，unit=TimeUtil.SECONDS 即非核心线程的存活时间为2秒
workQueue=new LinkedBlockingDeque<>(3) 即阻塞队列中最大能容纳三个等待的任务
threadFactory=Executors.defaultThreadFactory() 即创建线程的工厂为默认的线程工厂
handler=new ThreadPoolExecutor.AbortPolicy() 即使用AbortPolicy拒绝策略
运行一波：
public static void main(String[] args) { ExecutorService executorService = new ThreadPoolExecutor( 2, 5, 2L, TimeUnit.SECONDS, new LinkedBlockingDeque<>(3), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy()); for (int i = 0; i < 8; i++) { executorService.execute(()->{ System.out.println(Thread.currentThread().getName()+"\t 执行任务"); }); } }
结果如下：
用到了五个线程，完成了8个任务。
如果把任务数改一改，改成i < 9，运行一波，结果如下：
显然，有一个任务被拒绝了。
所以，得出一个结论，线程池可处理的最大任务数=maximumPoolSize+阻塞队列的最大容量数
6.线程池的四大拒绝策略
（1）AbortPolicy（默认）：直接抛出RejectedExecutionException异常，阻止系统正常运行
（2）CallerRunsPolicy：运行者调用的一种调节机制，该策略不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
（3）DiscardPolicy：默默地丢弃无法处理的任务，不予任何处理也不抛出异常，如果允许任务丢失，这是最好的一种策略
（4）DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入到队列中，尝试再次提交当前任务
7.分支合并框架
将一个复杂的任务拆分成多个小任务，再把小任务的结果合并，得到该复杂任务的结果。
以下是计算0~100的和的案例：
package com.Zhongger.Day08; import java.util.concurrent.ExecutionException; import java.util.concurrent.ForkJoinPool; import java.util.concurrent.ForkJoinTask; import java.util.concurrent.RecursiveTask; /** * @Author Zhongger * @Description * @Date */ public class ForkJoinDemo { public static void main(String[] args) throws ExecutionException, InterruptedException { MyTask myTask = new MyTask(0, 100); ForkJoinPool forkJoinPool = new ForkJoinPool(); ForkJoinTask<Integer> forkJoinTask = forkJoinPool.submit(myTask); System.out.println(forkJoinTask.get()); forkJoinPool.shutdown(); } } class MyTask extends RecursiveTask<Integer>{ private static final Integer ADJUST_VALUE=10; private int begin; private int end; private int result; public MyTask(int begin, int end) { this.begin = begin; this.end = end; } @Override protected Integer compute() { if ((end-begin)<=ADJUST_VALUE){ for (int i = begin; i <= end; i++) { result=result+i; } }else { int middle=(end+begin)/2; MyTask myTask1 = new MyTask(begin, middle); MyTask myTask2 = new MyTask(middle + 1, end); myTask1.fork(); myTask2.fork(); result=myTask1.join()+myTask2.join(); } return result; } }
结果为：
8.异步回调
package com.Zhongger.Day08; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; /** * @Author Zhongger * @Description * @Date */ public class CompletableFutureDemo { public static void main(String[] args) throws ExecutionException, InterruptedException { //异步调用，无返回值 CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> { System.out.println(Thread.currentThread().getName() + "无返回值，update mysql ok"); }); completableFuture.get(); //异步回调 CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> { System.out.println(Thread.currentThread().getName() + "无返回值，insert mysql ok"); int flag=10/0; return 1024; }).whenComplete((t,u)->{ System.out.println("t:"+t); System.out.println("u:"+u); }).exceptionally(f->{ System.out.println("exception:"+f.getMessage()); return 404; });//有返回值 System.out.println(integerCompletableFuture.get()); } }
9.总结
Java多线程的学习就暂告一段落了，掌握程度只能说是了解吧，后期还要多多巩固，并且多看看面试题，加油！
