【愚公系列】2023年10月 Java教学课程 074-线程池

🏆 作者简介，愚公搬代码
🏆《头衔》：华为云特约编辑，华为云云享专家，华为开发者专家，华为产品云测专家，CSDN博客专家，阿里云专家博主，腾讯云优秀博主，掘金优秀博主，51CTO博客专家等。
🏆《近期荣誉》：2022年CSDN博客之星TOP2，2022年华为云十佳博主等。
🏆《博客内容》：.NET、Java、Python、Go、Node、前端、IOS、Android、鸿蒙、Linux、物联网、网络安全、大数据、人工智能、U3D游戏、小程序等相关领域知识。
🏆🎉欢迎 👍点赞✍评论⭐收藏

🚀一、线程池

🔎1.线程生命周期介绍

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。

Java中的线程存在6种状态，每种线程状态的含义如下：

各个状态的转换，如下图所示：

🔎2.线程生命周期案例

🦋2.1 线程的生命周期-练习一

目的 : 本案例主要演示TIME_WAITING的状态转换。

需求： 编写一段代码，依次显示一个线程的这些状态：NEW -> RUNNABLE -> TIME_WAITING -> RUNNABLE -> TERMINATED

为了简化我们的开发，本次我们使用匿名内部类结合lambda表达式的方式使用多线程。

代码实现

public class ThreadStateDemo01 {public static void main(String[] args) throws InterruptedException {//定义一个内部线程Thread thread = new Thread(() -> {System.out.println("2.执行thread.start()之后，线程的状态：" + Thread.currentThread().getState());try {//休眠100毫秒Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("4.执行Thread.sleep(long)完成之后，线程的状态：" + Thread.currentThread().getState());});//获取start()之前的状态System.out.println("1.通过new初始化一个线程，但是还没有start()之前，线程的状态：" + thread.getState());//启动线程thread.start();//休眠50毫秒Thread.sleep(50);//因为thread1需要休眠100毫秒，所以在第50毫秒，thread处于sleep状态System.out.println("3.执行Thread.sleep(long)时，线程的状态：" + thread.getState());//thread1和main线程主动休眠150毫秒，所以在第150毫秒,thread早已执行完毕Thread.sleep(100);System.out.println("5.线程执行完毕之后，线程的状态：" + thread.getState() + "\n");}}

控制台输出

1.通过new初始化一个线程，但是还没有start()之前，线程的状态：NEW
2.执行thread.start()之后，线程的状态：RUNNABLE
3.执行Thread.sleep(long)时，线程的状态：TIMED_WAITING
4.执行Thread.sleep(long)完成之后，线程的状态：RUNNABLE
5.线程执行完毕之后，线程的状态：TERMINATED

🦋2.2 线程的生命周期-练习二

目的 : 本案例主要演示WAITING的状态转换。

需求 ： 编写一段代码，依次显示一个线程的这些状态：NEW -> RUNNABLE -> WAITING -> RUNNABLE -> TERMINATED

代码实现 :

public class ThreadStateDemo02 {public static void main(String[] args) throws InterruptedException {//定义一个对象，用来加锁和解锁Object obj = new Object();//定义一个内部线程Thread thread1 = new Thread(() -> {System.out.println("2.执行thread.start()之后，线程的状态：" + Thread.currentThread().getState());synchronized (obj) {try {//thread1需要休眠100毫秒Thread.sleep(100);//thread1100毫秒之后，通过wait()方法释放obj对象是锁obj.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("4.被object.notify()方法唤醒之后，线程的状态：" + Thread.currentThread().getState());});//获取start()之前的状态System.out.println("1.通过new初始化一个线程，但是还没有start()之前，线程的状态：" + thread1.getState());//启动线程thread1.start();//main线程休眠150毫秒Thread.sleep(150);//因为thread1在第100毫秒进入wait等待状态，所以第150秒肯定可以获取其状态System.out.println("3.执行object.wait()时，线程的状态：" + thread1.getState());//声明另一个线程进行解锁new Thread(() -> {synchronized (obj) {//唤醒等待的线程obj.notify();}}).start();//main线程休眠10毫秒等待thread1线程能够苏醒Thread.sleep(10);//获取thread1运行结束之后的状态System.out.println("5.线程执行完毕之后，线程的状态：" + thread1.getState() + "\n");}}

控制台输出结果

1.通过new初始化一个线程，但是还没有start()之前，线程的状态：NEW
2.执行thread.start()之后，线程的状态：RUNNABLE
3.执行object.wait()时，线程的状态：WAITING
4.被object.notify()方法唤醒之后，线程的状态：RUNNABLE
5.线程执行完毕之后，线程的状态：TERMINATED

🦋2.3 线程的生命周期-练习三

目的 : 本案例主要演示BLOCKED的状态转换。

需求 ： 编写一段代码，依次显示一个线程的这些状态：NEW -> RUNNABLE -> BLOCKED -> RUNNABLE -> TERMINATED

public class ThreadStateDemo03 {public static void main(String[] args) throws InterruptedException {//定义一个对象，用来加锁和解锁Object obj2 = new Object();//定义一个线程，先抢占了obj2对象的锁new Thread(() -> {synchronized (obj2) {try {Thread.sleep(100);              //第一个线程要持有锁100毫秒obj2.wait();                          //然后通过wait()方法进行等待状态，并释放obj2的对象锁} catch (InterruptedException e) {e.printStackTrace();}}}).start();//定义目标线程，获取等待获取obj2的锁Thread thread = new Thread(() -> {System.out.println("2.执行thread.start()之后，线程的状态：" + Thread.currentThread().getState());synchronized (obj2) {try {Thread.sleep(100);              //thread3要持有对象锁100毫秒obj2.notify();                        //然后通过notify()方法唤醒所有在ojb2上等待的线程继续执行后续操作} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("4.阻塞结束后，线程的状态：" + Thread.currentThread().getState());});//获取start()之前的状态System.out.println("1.通过new初始化一个线程，但是还没有thread.start()之前，线程的状态：" + thread.getState());//启动线程thread.start();//先等100毫秒Thread.sleep(50);//第一个线程释放锁至少需要100毫秒，所以在第50毫秒时，thread正在因等待obj的对象锁而阻塞System.out.println("3.因为等待锁而阻塞时，线程的状态：" + thread.getState());//再等300毫秒Thread.sleep(300);//两个线程的执行时间加上之前等待的50毫秒总共是250毫秒，所以第300毫秒，所有的线程都已经执行完毕System.out.println("5.线程执行完毕之后，线程的状态：" + thread.getState());}}

控制台输出结果

1.通过new初始化一个线程，但是还没有thread.start()之前，线程的状态：NEW
2.执行thread.start()之后，线程的状态：RUNNABLE
3.因为等待锁而阻塞时，线程的状态：BLOCKED
4.阻塞结束后，线程的状态：RUNNABLE
5.线程执行完毕之后，线程的状态：TERMINATED

🔎3.线程池介绍

概述 :

线程池是一种预先创建一定数量的线程，这些线程在系统启动时就被创建并保存在一个池中。当需要执行任务时，可以直接从池中取出一个线程来执行任务，这样可以避免频繁创建和销毁线程所带来的性能开销。

线程池通常包含以下几个组成部分：

1. 任务队列：用于存放待执行的任务。

2. 线程池管理器：用于管理线程池的创建、初始化、销毁等操作。

3. 工作线程：线程池中的线程，用于执行任务。

4. 执行任务：线程池中的任务，可以是代码块、函数、方法等。

线程池的优点在于降低了线程创建、销毁的开销，可以重复利用已创建的线程，提高系统的响应速度和处理能力。同时，线程池还能够限制并发线程的数量，防止由于线程数量过多而导致系统资源耗尽的问题。

线程池的设计思路 :

线程池是一种用来管理和复用线程以减少线程创建和销毁的开销的技术。它的设计思路可以概括为以下几个步骤：

1. 创建线程池：创建一个线程池，包括线程池大小、等待队列、线程拒绝策略等参数。

2. 初始化线程池：根据线程池大小，创建一定数量的线程，并将它们存放在等待队列中，以备处理任务。

3. 提交任务：当有任务需要处理时，将任务提交到等待队列中，等待线程池中的线程进行处理。

4. 线程执行任务：线程池中的线程从等待队列中取出任务并执行。

5. 处理线程中的异常：如果线程在执行任务时出现异常，需要进行异常处理以避免线程停止运行。

6. 完成任务后回收线程：当线程完成任务后，将线程返回到线程池中以便于下次任务处理。

7. 关闭线程池：当线程池不再需要时，需要关闭线程池，停止线程的执行，并且释放线程池中的资源。

🔎4.线程池实现的API、参数说明

Java中线程池的实现是通过java.util.concurrent包中的ExecutorService接口及其子类来实现的。常用的线程池实现类有ThreadPoolExecutor和ScheduledThreadPoolExecutor。

下面是ThreadPoolExecutor的构造方法及参数说明：

public ThreadPoolExecutor(int corePoolSize, // 线程池核心线程数int maximumPoolSize, // 线程池最大线程数long keepAliveTime, // 线程池中非核心线程的闲置超时时间TimeUnit unit, // keepAliveTime的时间单位BlockingQueue<Runnable> workQueue, // 工作队列，存储还未执行的任务ThreadFactory threadFactory, // 线程工厂，用于创建新线程RejectedExecutionHandler handler) // 拒绝策略，用于处理队列已满，无法执行新任务的情况

常用参数说明：

• corePoolSize：线程池维护的核心线程数，可以保持常驻的线程数，即使线程没有任务也不会销毁，除非设置了allowCoreThreadTimeOut参数。
• maximumPoolSize：线程池允许创建的最大线程数，当核心线程池已满时，新的任务会被加入到工作队列中，并且当工作队列也满了并且还有新的任务加入时，才会创建新的线程来执行任务，直到线程数达到了maximumPoolSize限制。
• keepAliveTime：非核心线程在闲置时间超过keepAliveTime时会被销毁，直到线程数量收缩到corePoolSize。如果调用了allowCoreThreadTimeOut，则所有的线程都会根据keepAliveTime的值进行超时销毁。
• unit：keepAliveTime的时间单位，可选值包括TimeUnit.SECONDS, TimeUnit.MILLISECONDS, TimeUnit.MINUTES, TimeUnit.HOURS等。
• workQueue：任务队列，用于存储待执行的任务，常用的实现类有：ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。
• threadFactory：用于创建新的线程，默认的实现是默认的线程工厂DefaultThreadFactory，可以自定义线程工厂，来设置线程名称、优先级等信息。
• handler：拒绝策略，当工作队列已满或线程池已经达到最大线程数，未被执行的任务就会被拒绝，并交给指定的拒绝策略来处理，常用的策略有：AbortPolicy（抛出RejectedExecutionException），CallerRunsPolicy（在调用者线程中直接执行），DiscardOldestPolicy（丢弃队列头部最早的任务），DiscardPolicy（直接丢弃任务）。

ScheduledThreadPoolExecutor的构造方法及参数说明基本和ThreadPoolExecutor相同，只是多了一个ScheduledExecutorService的特点，即可以支持定时和周期性任务的执行，常用的方法包括schedule、scheduleAtFixedRate、scheduleWithFixedDelay等。

🔎5.线程池处理Runnable任务

具体步骤如下：

1. 创建ThreadPoolExecutor对象，可以使用ThreadPoolExecutor构造器或者通过Executors工厂类提供的newCachedThreadPool()、newFixedThreadPool()、newSingleThreadExecutor()等方法创建ThreadPoolExecutor对象。

2. 创建Runnable对象，重写run()方法。

3. 使用execute()方法将Runnable任务提交至线程池执行。

4. 在任务执行完成后，需要调用ThreadPoolExecutor对象的shutdown()方法关闭线程池。

下面是一个使用ThreadPoolExecutor处理Runnable任务的示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;public class ThreadPoolExecutorDemo {public static void main(String[] args) {// 创建ThreadPoolExecutor对象ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(3);// 创建Runnable任务Runnable task1 = new MyRunnable("Task 1");Runnable task2 = new MyRunnable("Task 2");Runnable task3 = new MyRunnable("Task 3");// 提交任务executor.execute(task1);executor.execute(task2);executor.execute(task3);// 关闭线程池executor.shutdown();}static class MyRunnable implements Runnable {private String taskName;public MyRunnable(String taskName) {this.taskName = taskName;}@Overridepublic void run() {System.out.println("Task " + taskName + " is running on thread " + Thread.currentThread().getName());try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Task " + taskName + " is completed.");}}
}

在上述示例代码中，我们使用了Executors工厂类提供的newFixedThreadPool()方法创建了一个大小为3的线程池ThreadPoolExecutor对象。然后创建了3个Runnable任务，并使用execute()方法将任务提交至线程池执行。在任务执行完成后，需要调用ThreadPoolExecutor对象的shutdown()方法关闭线程池。

🔎6.线程池处理Callable任务

在Java中，ThreadPoolExecutor类是一种用于执行线程池任务的工具类。它使用一个线程池来管理和分配线程，并且在执行任务时，可以控制线程的数量，以及限制最大的并发任务数。

使用ThreadPoolExecutor类处理Callable任务的步骤如下：

1. 创建一个ThreadPoolExecutor对象，并设置线程池的相关参数，例如核心线程数、最大线程数、等待队列容量等。

2. 创建一个Callable任务，实现Callable接口中的call()方法。

3. 使用线程池对象的submit()方法提交Callable任务，并返回一个Future对象。

4. 使用Future对象的get()方法等待Callable任务执行完成，并获取任务的返回值。

下面是一个示例代码，演示了如何使用ThreadPoolExecutor类处理Callable任务：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class ThreadPoolExecutorDemo {public static void main(String[] args) {// 1、创建一个线程池对象/**public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)*/// ExecutorService pool = new ThreadPoolExecutor(3,5,//         6, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5)// , Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());// 创建线程池对象，设置参数ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<>(10));// 提交Callable任务Future<String> future = executor.submit(new MyCallable());try {// 等待任务完成，并获取返回值String result = future.get();System.out.println("任务执行结果：" + result);} catch (InterruptedException | ExecutionException e) {e.printStackTrace();}// 关闭线程池executor.shutdown();}static class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {// 执行任务Thread.sleep(1000);return "任务执行完成";}}
}

在上面的示例中，我们创建了一个ThreadPoolExecutor对象，并设置核心线程数为2，最大线程数为4，等待队列容量为10。然后，我们创建了一个MyCallable对象，实现了Callable接口中的call()方法，用于模拟一个任务需要执行1秒钟的时间。最后，我们使用线程池对象的submit()方法提交Callable任务，并返回一个Future对象，调用Future对象的get()方法等待任务执行完成，并获取返回值。

需要注意的是，在程序结束后必须手动关闭线程池，否则会导致程序一直处于运行状态。可以使用executor.shutdown()方法来关闭线程池。

🔎7.Executors工具类实现线程池

Executors工具类提供了多种不同类型的线程池，每种线程池都有其独特的特点。下面对参数进行简要介绍：

1. newFixedThreadPool(int nThreads)：创建一个含有固定线程数的线程池，不会创建新的线程，如果所有线程都在执行任务，则任务将在队列中等待。核心线程池大小为nThreads，最大线程池大小也为nThreads，线程空闲时间为0，使用无界的LinkedBlockingQueue作为等待队列。

2. newCachedThreadPool()：创建一个可以根据需要创建新线程的线程池。核心线程池大小为0，最大线程池大小为Integer.MAX_VALUE，线程空闲时间为60秒，使用SynchronousQueue作为等待队列，适用于执行大量短期异步任务的场景。

3. newSingleThreadExecutor()：创建一个只有一个线程的线程池，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行，并且在该线程中序列化所有提交给它的任务。

4. newScheduledThreadPool(int corePoolSize)：创建一个含有指定线程数的线程池，支持定时以及周期性执行任务的需求。

下面是一个完整的示例，使用Executors创建一个FixedThreadPool并提交10个任务：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class ThreadPoolExample {public static void main(String[] args) {// 创建大小为5的线程池ExecutorService executorService = Executors.newFixedThreadPool(5);for(int i=0; i<10; i++) {executorService.execute(new Task(i));}// 关闭线程池executorService.shutdown();}private static class Task implements Runnable {private final int taskId;public Task(int taskId) {this.taskId = taskId;}@Overridepublic void run() {System.out.println("Task " + taskId + " is running.");}}
}

输出结果：

Task 0 is running.
Task 4 is running.
Task 2 is running.
Task 3 is running.
Task 1 is running.
Task 5 is running.
Task 6 is running.
Task 7 is running.
Task 8 is running.
Task 9 is running.

可以看到，线程池中有5个线程在执行任务，其他任务在等待队列中等待执行。

🚀感谢：给读者的一封信

亲爱的读者，

我在这篇文章中投入了大量的心血和时间，希望为您提供有价值的内容。这篇文章包含了深入的研究和个人经验，我相信这些信息对您非常有帮助。

如果您觉得这篇文章对您有所帮助，我诚恳地请求您考虑赞赏1元钱的支持。这个金额不会对您的财务状况造成负担，但它会对我继续创作高质量的内容产生积极的影响。

我之所以写这篇文章，是因为我热爱分享有用的知识和见解。您的支持将帮助我继续这个使命，也鼓励我花更多的时间和精力创作更多有价值的内容。

如果您愿意支持我的创作，请扫描下面二维码，您的支持将不胜感激。同时，如果您有任何反馈或建议，也欢迎与我分享。

再次感谢您的阅读和支持！

最诚挚的问候， “愚公搬代码”