JavaWeb14-线程池

目录

1.传统线程的缺点

2.线程池的定义

3.线程池的优点

4.线程池的创建/使用（2类7种）

4.1.通过Executors（执行器）自动创建（6种）

①Executors.newFixedThreadPool：创建⼀个固定⼤⼩的线程池，可控制并发的线程数，超出的线程会在队列中等待。

--->PS：submit VS execute

--->PS：有返回值的线程池实现

--->PS：线程池中的线程工厂

②Executors.newCachedThreadPool：创建⼀个可缓存的线程池，若线程数超过处理所需，缓存⼀段时间后会回收，若线程数量不够，则新建线程，线程数随任务量而定（前提CPU性能好）。

③Executors.newSingleThreadExecutor：创建单个线程数的线程池，它可以保证先进先出的执⾏顺序。

--->PS：（常见面试题）newSingleThreadExecutor：创建单个线程数的线程池，那为何不直接使用线程？单线程线程池的意义？

④Executors.newScheduledThreadPool：创建⼀个可以执⾏延迟任务的线程池。

--->a.延迟执行一次

--->b.固定频率执行scheduleAtFixedRate

--->c.固定频率执行scheduleWithFixedDelay

 --->PS：scheduleAtFixedRate VS scheduleWithFixedDelay

⑤Executors.newSingleThreadScheduledExecutor：创建⼀个单线程的可以执行延迟任务的线程池。

⑥Executors.newWorkStealingPool：根据当前服务器的CPU创建⼀个抢占式执⾏的线程池（任务执⾏顺序不确定）【JDK 1.8 添加】。

4.2.通过ThreadPoolExecutor手动创建（1种）

⑦ThreadPoolExecutor：重点掌握，最原始方式，推荐使用。

--->Executors自动创建线程池返回的线程池对象的弊端如下：

--->a.ThreadPoolExecutor 参数说明(包含 7 个参数可供设置，最少需要设置5个参数)

--->b.线程池执行流程

--->c.线程池拒绝策略（4【JDK提供】+1【自定义】）

5.线程池状态（5种）

①RUNNING：

②SHUTDOWN：

③STOP：

④TIDYING：

⑤TERMINATED：

a.各个状态的转换过程

b.shutdown VS shutdownNow

6.究竟选用哪种线程池？

---

1.传统线程的缺点

• 有任务时创建线程，没任务时结束线程：创建线程需要开辟本地线程栈、虚拟机栈、程序计数器等私有线程内存，消耗的时候也需要释放这些内存。频繁地创建和销毁需要⼀定的开销。

• 线程没有任务队列的任务管理功能：当任务数远远⼤于线程可以承载的数量之后，不能友好地进⾏任务拒绝。

2.线程池的定义

线程池（ThreadPool）是⼀种基于池化思想管理和使⽤线程的机制。

它是将多个线程预先存储在⼀个“池⼦”内，当有任务出现时可以避免重新创建和销毁线程所带来性能开销，只需要从“池⼦”内取出相应的线程执⾏对应的任务即可。

池化思想在计算机的应⽤也⽐较⼴泛：

• 内存池(Memory Pooling)：预先申请内存，提升申请内存速度，减少内存碎⽚。

• 连接池(Connection Pooling)：预先申请数据库连接，提升申请连接的速度，降低系统的开销。

• 实例池(Object Pooling)：循环使⽤对象，减少资源在初始化和释放时的昂贵损耗。

3.线程池的优点

1. 复用线程：避免线程重复创建和销毁的性能开销。
2. 提⾼响应速度：任务到达时，⽆需等待线程创建即可⽴即执⾏。
3. 控制线程数量：避免因线程创建过多而导致OOM（out of memory内存溢出）情况。
4. 提供内存管理功能：可实现任务缓存和任务拒绝。
5. 提供更多功能：比如定时任务，允许任务延期执⾏或定期执⾏。

同时阿⾥巴巴在其《Java开发⼿册》中也强制规定：线程资源必须通过线程池提供，不允许在应⽤中⾃⾏显式创建线程。

4.线程池的创建/使用（2类7种）

4.1.通过Executors（执行器）自动创建（6种）

①Executors.newFixedThreadPool：创建⼀个固定⼤⼩的线程池，可控制并发的线程数，超出的线程会在队列中等待。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*** 创建一个固定大小的线程池*/
public class ThreadPoolDemo1 {public static void main(String[] args) {//1.创建了一个包含5个线程的线程池ExecutorService threadPool = Executors.newFixedThreadPool(5);//2.使用submit线程池执行任务一for (int i = 0; i < 5; i++) {//给线程池添加任务threadPool.submit(new Runnable() { //匿名内部类@Overridepublic void run() {System.out.println("线程名称：" + Thread.currentThread().getName());}});}//2.使用execute线程池执行任务二for (int i = 0; i < 10; i++) {//给线程池添加任务threadPool.execute(new Runnable() {@Overridepublic void run() {System.out.println("线程名称：" + Thread.currentThread().getName());}});}}
}

--->PS：submit VS execute

 

• submit：既支持有返回值，也支持无返回值。（推荐使用）
• execute：只支持无返回值。

--->PS：有返回值的线程池实现

import java.util.Random;
import java.util.concurrent.*;/*** 有返回值的线程池*/
public class ThreadPoolDemo2 {public static void main(String[] args) throws ExecutionException, InterruptedException {ExecutorService threadPool = Executors.newFixedThreadPool(5);Future<Integer> result = threadPool.submit(new Callable<Integer>() {@Overridepublic Integer call() throws Exception{int num = new Random().nextInt(10);System.out.println("生成随机数:" + num);return num;}});System.out.println("得到线程池返回结果:" + result.get()); //会有阻塞，会等到拿到返回值之后再去执行后面的代码}
}

上面代码是使用默认的线程工厂。

--->PS：线程池中的线程工厂

作用：为线程池提供线程的创建。

提供的功能：

1. 设置线程池中的线程的命名规则。
2. 设置线程的优先级。
3. 设置线程的分组。
4. 设置线程的类型（用户线程、守护/后台线程）。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import static java.lang.Thread.MAX_PRIORITY;/***线程工厂示例演示*/
public class ThreadPoolDemo3 {public static void main(String[] args) {//创建线程工厂ThreadFactory factory = new ThreadFactory() {@Overridepublic Thread newThread(Runnable r) {//!!!一定要注意要把任务Runnable设置给新创建的线程Thread thread = new Thread(r);//设置线程的命名规则thread.setName("我的线程-" + r.hashCode());//设置线程的优先级thread.setPriority(MAX_PRIORITY);return thread;}};ExecutorService service = Executors.newFixedThreadPool(5,factory);for (int i = 0; i < 5; i++) {service.submit(() -> {//任务Thread thread = Thread.currentThread();System.out.println("线程池开始执行了：" + thread.getName() + ",线程优先级：" + thread.getPriority());});}}
}

线程池里的线程永远处于存活状态，不会自动停止，除非调用线程池终止执行方法。

②Executors.newCachedThreadPool：创建⼀个可缓存的线程池，若线程数超过处理所需，缓存⼀段时间后会回收，若线程数量不够，则新建线程，线程数随任务量而定（前提CPU性能好）。

优点：更多任务数量产⽣相应的线程池。 当有突发的大量的任务时，建议使用此方式。

缺点：占⽤资源数量⽐较多。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*** 带缓存的线程池*/
public class ThreadPoolDemo4 {public static void main(String[] args) {//创建线程池ExecutorService service = Executors.newCachedThreadPool();for (int i = 0; i < 1000; i++) {//任务数量总共有1000个，最终执行结果 线程数量大概是300多个//i必须定义一个参数，才能去使用,必须是一个确定的参数int finalI = i;service.submit(() -> {System.out.println("i:" + finalI + "|线程名称" + Thread.currentThread().getName());});}}
}

若不关闭，会一直执行下去。

③Executors.newSingleThreadExecutor：创建单个线程数的线程池，它可以保证先进先出的执⾏顺序。

--->PS：（常见面试题）newSingleThreadExecutor：创建单个线程数的线程池，那为何不直接使用线程？单线程线程池的意义？

1. 复用线程。
2. 单线程的线程池提供了任务队列和拒绝策略（当任务队列满了Integer.MAX_VALUE之后，新来的任务就会执行拒绝策略）。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class ThreadPoolDemo7 {public static void main(String[] args) {ExecutorService service = Executors.newSingleThreadExecutor();for (int i = 0; i < 10; i++) {int finalI = i;service.submit(new Runnable() {@Overridepublic void run() {System.out.println("任务：" + finalI + "线程名:" + Thread.currentThread().getName());}});}}
}

④Executors.newScheduledThreadPool：创建⼀个可以执⾏延迟任务的线程池。

--->a.延迟执行一次

import java.time.LocalDateTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;/*** 创建执行定时任务的线程池*/
public class ThreadPoolDemo5 {public static void main(String[] args) {//创建线程池ScheduledExecutorService service = Executors.newScheduledThreadPool(5);System.out.println("添加任务的时间:" + LocalDateTime.now());//执行一次的定时任务scheduleTest(service);}/*** 执行一次的定时任务* @param service*/private static void scheduleTest(ScheduledExecutorService service) {//执行定时任务（延迟3秒执行）。这个延迟任务只能执行一次，不能继续执行。//延迟执行一次定时任务service.schedule(new Runnable() {@Overridepublic void run() {System.out.println("执行了任务:" + LocalDateTime.now());//参数1：执行的任务}},3, TimeUnit.SECONDS);//参数2：延迟多久进行执行； 参数3：是参数2的时间单位描述}
}

--->b.固定频率执行scheduleAtFixedRate

import java.time.LocalDateTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;/*** 创建执行定时任务的线程池*/
public class ThreadPoolDemo5 {public static void main(String[] args) {//创建线程池ScheduledExecutorService service = Executors.newScheduledThreadPool(5);System.out.println("添加任务的时间:" + LocalDateTime.now());//2s之后开始执行定时任务，定时任务每隔4s执行一次service.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println("执行任务：" + LocalDateTime.now());}},2,4, TimeUnit.SECONDS);}
}

--->c.固定频率执行scheduleWithFixedDelay

import java.time.LocalDateTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;/*** 创建执行定时任务的线程池*/
public class ThreadPoolDemo5 {public static void main(String[] args) {//创建线程池ScheduledExecutorService service = Executors.newScheduledThreadPool(5);System.out.println("添加任务的时间:" + LocalDateTime.now());//2s之后开始执行定时任务，定时任务每隔4s执行一次service.scheduleWithFixedDelay(new Runnable() {@Overridepublic void run() {System.out.println("执行时间：" + LocalDateTime.now());}},2,4,TimeUnit.SECONDS);}
}

 --->PS：scheduleAtFixedRate VS scheduleWithFixedDelay

①scheduleAtFixedRate 是以上⼀次任务的开始时间，作为下次定时任务的参考时间的（参考时间+延迟任务=任务执⾏）。

import java.time.LocalDateTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;/*** 创建执行定时任务的线程池*/
public class ThreadPoolDemo5 {public static void main(String[] args) {//创建线程池ScheduledExecutorService service = Executors.newScheduledThreadPool(5);System.out.println("添加任务的时间:" + LocalDateTime.now());//2s之后开始执行定时任务，定时任务每隔4s执行一次service.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println("执行任务：" + LocalDateTime.now());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}},2,4, TimeUnit.SECONDS);}
}

注意：

如果任务执⾏时间⼤于延迟任务设定的间隔时间，则会以任务执行时间为定时任务间隔周期来执行，即哪个值大就用哪个值作为定时任务间隔周期。

public class ThreadPoolDemo5 {public static void main(String[] args) {//创建线程池ScheduledExecutorService service = Executors.newScheduledThreadPool(5);System.out.println("添加任务的时间:" + LocalDateTime.now());//2s之后开始执行定时任务，定时任务每隔3s执行一次service.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {System.out.println("执行任务：" + LocalDateTime.now());try {Thread.sleep(4000);} catch (InterruptedException e) {e.printStackTrace();}}},2,3, TimeUnit.SECONDS);}
}

②scheduleWithFixedDelay 是以上⼀次任务的结束时间，作为下次定时任务的参考时间的。

public class ThreadPoolDemo5 {public static void main(String[] args) {//创建线程池ScheduledExecutorService service = Executors.newScheduledThreadPool(5);System.out.println("添加任务的时间:" + LocalDateTime.now());//2s之后开始执行定时任务，定时任务每隔4s执行一次service.scheduleWithFixedDelay(new Runnable() {@Overridepublic void run() {System.out.println("执行时间：" + LocalDateTime.now());try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}},2,4,TimeUnit.SECONDS);}
}

⑤Executors.newSingleThreadScheduledExecutor：创建⼀个单线程的可以执行延迟任务的线程池。

newSingleThreadScheduledExecutor是newScheduledThreadPool的单线程版本。

import java.time.LocalDateTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;public class ThreadPoolDemo6 {public static void main(String[] args) {//创建执行定时任务的单线程线程池ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();System.out.println("添加任务的时间：" + LocalDateTime.now());service.schedule(new Runnable() {@Overridepublic void run() {System.out.println("执行任务：" + LocalDateTime.now());}},2, TimeUnit.SECONDS);}
}

⑥Executors.newWorkStealingPool：根据当前服务器的CPU创建⼀个抢占式执⾏的线程池（任务执⾏顺序不确定）【JDK 1.8 添加】。

优点：智能、高效。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class ThreadPoolDemo8 {public static void main(String[] args) {//根据当前设备的配置自动生成线程池ExecutorService service = Executors.newWorkStealingPool();for (int i = 0; i < 100; i++) {service.submit(() -> {System.out.println("线程名:" + Thread.currentThread().getName());});}while(!service.isTerminated()){}}
}

4.2.通过ThreadPoolExecutor手动创建（1种）

⑦ThreadPoolExecutor：重点掌握，最原始方式，推荐使用。

--->Executors自动创建线程池返回的线程池对象的弊端如下：

1. FixedThreadPool和SingleThreadPool：允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2. CachedThreadPool：允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

OOM代码演示：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*** 演示OOM*/
public class ThreadPoolDemo9 {static class OOMClass{//1M空间（M KB Byte）private byte[] bytes = new byte[1 * 1024 * 1024];}public static void main(String[] args) {ExecutorService service = Executors.newCachedThreadPool();Object[] objects = new Object[15];for (int i = 0; i < 15; i++) {int finalI = i;service.execute(() -> {try {Thread.sleep(finalI * 200);} catch (InterruptedException e) {e.printStackTrace();}OOMClass oomClass = new OOMClass();objects[finalI] = oomClass;System.out.println("执行第" + finalI + "次");});}}
}

关于参数设置

• -XX：标准设置，所有 HotSpot 都⽀持的参数。
• -X：⾮标准设置，特定的 HotSpot 才⽀持的参数。
• -D：程序参数设置，-D参数=value，程序中使⽤：System.getProperty("获取")。
• mx 是 memory max 的简称。

《阿里巴巴Java开发手册》中强制规定：线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样让程序员更加明确线程池的运行规则，规避资源耗尽的风险。

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;/*** 手动方式创建线程池*/
public class ThreadPoolDemo10 {public static void main(String[] args) {ThreadFactory factory = new ThreadFactory() {@Overridepublic Thread newThread(Runnable r) {Thread thread = new Thread(r);return thread;}};//手动方式创建线程池ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 10, TimeUnit.SECONDS, new LinkedBlockingDeque<>(100), factory, new ThreadPoolExecutor.DiscardPolicy());//设置任务for (int i = 0; i < 10; i++) {executor.submit(() -> {System.out.println("线程名称：" + Thread.currentThread().getName());});}//终止线程executor.shutdown();//当任务执行完直接就结束了}
}

--->a.ThreadPoolExecutor 参数说明(包含 7 个参数可供设置，最少需要设置5个参数)

1. corePoolSize：核心线程数（正式员工的数量），可以⼤致理解为⻓期驻留的线程数⽬（除⾮设置了allowCoreThreadTimeOut）。对于不同的线程池，这个值可能会有很⼤区别，⽐如 newFixedThreadPool 会将其设置为 nThreads，⽽对于 newCachedThreadPool 则是为0。

2. maximumPoolSize：最大线程数（正式员工+临时员工的数量），就是线程不够时能够创建的最⼤线程数。同样进⾏对⽐，对于newFixedThreadPool，当然就是 nThreads，因为其要求是固定⼤⼩，⽽ newCachedThreadPool 则是 Integer.MAX_VALUE。

3. keepAliveTime：空闲线程的保活时间（针对临时员工），如果线程的空闲时间超过这个值，那么将会被关闭。注意此值⽣效条件必须满⾜：空闲时间超过这个值，并且线程池中的线程数少于等于核⼼线程数 corePoolSize。当然核⼼线程默认是不会关闭的，除⾮设置了allowCoreThreadTimeOut(true)那么核⼼线程也可以被回收。

4. TimeUnit：对参数3的时间单位描述。

5. BlockingQueue：任务/阻塞队列，⽤于存储线程池的待执⾏任务。必须要设置参数值；若不设置参数值，默认为Integer.MAX_VALUE，也会导致OOM问题。

6. threadFactory：用于生成线程的线程工厂，可设置线程属性，⼀般我们可以⽤默认的就可以了。

7. handler：拒绝策略管理器，处理极端问题。当线程池已经满了，但是又有新的任务提交的时候，该采取什么策略由这个来指定。有⼏种⽅式可供选择，像抛出异常、直接拒绝然后返回等，也可以⾃⼰实现相应的接⼝实现⾃⼰的逻辑。

--->b.线程池执行流程

--->c.线程池拒绝策略（4【JDK提供】+1【自定义】）

JDK提供的4种：

①AbortPolicy（默认的拒绝策略）：提示异常，拒绝执行。

②DiscardPolicy：忽略最新的任务。

③DiscardOldestPolicy：忽略旧任务（任务队列中的第一个任务）。

④CallerRunsPolicy：使用调用线程池的线程来执行任务~叫救援。

自定义的1种：

5.线程池状态（5种）

①RUNNING：

线程池创建之后的初始状态，这是最正常的状态：接受新的任务，处理等待队列中的任务。

②SHUTDOWN：

线程池不再接受新的任务提交，但是会继续处理等待队列中的任务，将其执行结束。

③STOP：

线程池不接受新的任务提交，不再处理等待队列中的任务，中断正在执⾏任务的线程。

④TIDYING：

该状态下所有的任务都销毁了，workCount 为 0。会执⾏钩⼦⽅法 terminated()。

⑤TERMINATED：

terminated() ⽅法结束后，线程池的状态就会变成这个。

a.各个状态的转换过程

• RUNNING -> SHUTDOWN：当调⽤了 shutdown() 后，会发⽣这个状态转换，这也是最重要的；
• (RUNNING or SHUTDOWN) -> STOP：当调⽤ shutdownNow() 后，会发⽣这个状态转换；
• SHUTDOWN -> TIDYING：当任务队列和线程池都清空后，会由 SHUTDOWN 转换为 TIDYING；  
• STOP -> TIDYING：当任务队列清空后，发⽣这个转换；
• TIDYING -> TERMINATED：当 terminated() ⽅法结束后。

b.shutdown VS shutdownNow

• shutdown 执⾏时线程池终⽌接收新任务，并且会将任务队列中的任务处理完；
• shutdownNow 执⾏时线程池终⽌接收新任务，并且会终⽌执⾏任务队列中的任务。

6.究竟选用哪种线程池？

阿⾥巴巴《Java开发⼿册》给的答案：推荐使⽤ThreadPoolExecutor 的⽅式进⾏线程池的创建，因为这种创建⽅式更可控，并且更加明确了线程池的运⾏规则，可以规避⼀些未知的⻛险。