【从零开始学习JAVA | 第四十篇】了解线程池

分手后的思念是犯贱 2023-10-14 15:13 44阅读 0赞

**目录**

前言：

线程池：

线程池的工作流程：

代码实现线程池：

任务拒绝策略：

线程池多大才算合适？

总结：

--------------------

## 前言： ##

> 在Java编程中，线程池是一个强大的工具，它能够管理和复用线程，提供高效的并发处理能力。通过线程池，我们可以有效地控制并发线程的数量，并降低线程创建和销毁的开销。本文将引导你深入了解Java中的线程池，探索其原理、用法和优势，为你提供一个更高效的编程方式。

![2ebb9e38739c48618672d7c5d8dc038c.png][]

>  **线程池的作用就是管理线程数量，减少线程频繁的创建和销毁**

## 线程池： ##

线程池是一种用于管理和复用线程的技术，它可以有效地处理并发任务并提高程序的性能和响应能力。线程池维护着一个线程队列，其中包含了一定数量的线程。当有新的任务到达时，线程池会从队列中选择一个空闲的线程来执行任务，而不是为每个任务都创建新的线程。

### 线程池的工作流程： ###

1.  创建线程池，包括初始化线程队列和创建指定数量的线程。
2.  将任务提交给线程池。可以通过将任务对象提交给线程池的方式来添加新的任务。
3.  线程池从任务队列中选择一个空闲的线程来执行任务。
4.  执行任务。线程池中的线程会执行任务对象中定义的操作。
5.  任务执行完成后，线程返回线程池并等待下一个任务。
6.  线程池继续从任务队列中选择新的任务并分配给空闲线程，循环执行以上步骤。![8c21a7d1a72d4544b862c0aed7517715.png][]

### 代码实现线程池： ###

1.创建线程池的工具类 ExecutorService：

*  public static ExecutorService newCachedThreadPool() 创建一个没有上限的线程池
 *  public static ExecutorService newCachedThreadPool(int int nthread) 创建一个有上限的线程池

> 其实第一个创建线程池不是真正没有上限，**他的上限是int的最大范围**，只不过因为实在是太大了，因此我们说没有上限。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class ThreadPoolExample {
        public static void main(String[] args) {
            // 创建一个固定大小为5的线程池
            ExecutorService threadPool = Executors.newFixedThreadPool(5);
    
            // 提交任务给线程池
            for (int i = 0; i < 10; i++) {
                final int taskId = i;
                threadPool.execute(new Runnable() {
                    public void run() {
                        try {
                            System.out.println("开始执行任务：" + taskId);
                            Thread.sleep(2000); // 模拟任务执行时间
                            System.out.println("任务执行完成：" + taskId);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
    
            // 关闭线程池
            threadPool.shutdown();
        }
    }

> 小技巧：
> 
> 通过打断点的方式，我们可以实时看到当前线程池中的线程数量：  
> ![0c19595d65ee4207b7ed77bd1c622d28.png][]

2.自定义创建线程池对象 ThreadPoolExecutor：

在Java中，我们可以使用ThreadPoolExecutor来自定义创建线程池对象。ThreadPoolExecutor是ExecutorService接口的一个实现类，它允许我们灵活地配置线程池的核心线程数、最大线程数、线程存活时间等参数。  
首先，我们需要导入java.util.concurrent包。然后，可以通过以下代码创建一个自定义的线程池对象：

public class test03 {
        public static void main(String[] args) {
            ThreadPoolExecutor pool = new ThreadPoolExecutor(
                    3,//核心线程数量
    
                    6,//最大线程数
    
                    60,//空闲线程最大存活时间
    
                    TimeUnit.SECONDS,//时间单位
    
                    new ArrayBlockingQueue<>(3),//指定任务队列最大长度
    
                    Executors.defaultThreadFactory(),//创建线程工厂
    
                    new ThreadPoolExecutor.AbortPolicy()//任务的拒绝策略
            );
            
        }
    }

在上述代码中，我们传入了核心线程数、最大线程数、非核心线程空闲超时时间以及任务队列等参数来创建线程池对象。你还可以根据需要，调整这些参数以满足你的实际需求。

> 1.  **核心线程数（corePoolSize）**：**核心线程数是线程池中一直存活的线程数量**。当提交一个任务时，如果当前核心线程数还未达到设定的值，线程池会创建新的核心线程来处理任务。即使核心线程处于空闲状态，它们也不会被回收。
> 2.  **最大线程数（maxPoolSize）**：**最大线程数是线程池中能容纳的最大线程数量。当提交的任务超过了核心线程数并且任务队列已满时，线程池会创建新的线程来执行任务**，直到达到最大线程数。超过最大线程数的任务将会被拒绝执行。
> 3.  **非核心线程空闲超时时间（keepAliveTime）**：当线程池中的线程数量超过核心线程数，并且这些线程处于空闲状态时，非核心线程会被回收。**空闲超时时间设定了非核心线程的最长存活时间，超过这个时间，空闲的非核心线程将被回收**。

### 任务拒绝策略： ###

在Java中，任务拒绝策略用于处理线程池无法接受更多任务时的行为。当线程池已满并且工作队列已满或达到最大容量时，新提交的任务可能会被拒绝执行。Java提供了四种默认的任务拒绝策略：

1.  **AbortPolicy（中止策略）**：这是默认的任务拒绝策略。当线程池无法接受新任务时，新提交的任务会立即抛出RejectedExecutionException异常。
2.  **CallerRunsPolicy（调用者运行策略）**：如果线程池无法接受新任务，则由提交任务的线程来执行该任务。这意味着任务的执行将回退到调用线程中执行，从而降低了整体的并发度。
3.  **DiscardPolicy（丢弃策略）**：当线程池无法接受新任务时，新提交的任务将被静默丢弃，不会抛出任何异常。这意味着被丢弃的任务将不会被执行。
4.  **DiscardOldestPolicy（丢弃最旧策略）**：当线程池无法接受新任务时，线程池会丢弃工作队列中最旧的任务（即最先提交的任务），然后尝试再次提交新任务。

除了这四种默认的拒绝策略外，还可以通过实现RejectedExecutionHandler接口来自定义任务拒绝策略。通过实现该接口，可以定义自己的拒绝策略逻辑，例如将被拒绝的任务记录下来或将其放入其他队列中等。然后，可以将自定义的拒绝策略传递给线程

**在自定义线程池中，我们需要掌握好自定义过程中的七个参数的意义。**

### 线程池多大才算合适？ ###

线程池大小的计算是有计算公式的，在介绍计算公式之前，我们要先讲解一下什么是最大并行数

> 最大并行数指的是在给定的系统环境下同时执行的最大线程或任务数。

线程池大小计算公式：

**1.CPU密集型运算**：  
在CPU密集型运算中，任务主要是由CPU执行，涉及较少的I/O操作。在这种情况下，线程池的大小可以通过以下公式计算：

最大并行数+1

**2.I/O密集型运算：**

在I/O密集型运算中，任务涉及大量的I/O操作，例如读取文件、网络通信等。在这种情况下，由于任务执行时间中有很多时间被阻塞在I/O等待上，可以通过以下公式计算线程池的大小：

Nthreads = Ncpu * Ucpu * (1 + (W/C))

*  `Nthreads` 是线程池中的线程数。
 *  `Ncpu` 是计算机中的CPU核心数。
 *  `Ucpu` 是期望的CPU利用率（0 <= Ucpu <= 1）。它表示期望的CPU工作时间与总时间的比例。
 *  `W/C` 通常设置为较大的值，以便在I/O等待期间可以让CPU执行其他任务。

在I/O密集型任务中，通过增加线程池的大小可以更好地利用I/O等待的时间，提高整体的并发性能。然而，过量的线程数也会增加上下文切换的开销，因此需要根据实

## 总结： ##

今天我们学习了线程池的使用，学习了调用库类实现线程池以及自定义线程池。而多线程的内容其实并没有介绍完毕，我们将会在后面详细的介绍线程中比较重要的乐观锁以及悲观锁，还有大名鼎鼎的CAS算法。

如果我的内容对你有帮助，请**点赞，评论，收藏**。创作不易，大家的支持就是我坚持下去的动力！

![69e9169c980f43e0aad31ff9ada88a9c.png][]

[2ebb9e38739c48618672d7c5d8dc038c.png]: https://img-blog.csdnimg.cn/2ebb9e38739c48618672d7c5d8dc038c.png
[8c21a7d1a72d4544b862c0aed7517715.png]: https://img-blog.csdnimg.cn/8c21a7d1a72d4544b862c0aed7517715.png
[0c19595d65ee4207b7ed77bd1c622d28.png]: https://img-blog.csdnimg.cn/0c19595d65ee4207b7ed77bd1c622d28.png
[69e9169c980f43e0aad31ff9ada88a9c.png]: https://img-blog.csdnimg.cn/69e9169c980f43e0aad31ff9ada88a9c.png