为什么要用线程池？

红太狼 2024-03-16 10:56 76阅读 0赞

线程池是一种管理和复用线程资源的机制，它由一个线程池管理器和一组工作线程组成。线程池管理器负责创建和销毁线程池，以及管理线程池中的工作线程。工作线程则负责执行具体的任务。

线程池的主要作用是管理和复用线程资源，避免了线程的频繁创建和销毁所带来的开销。  
线程池包含两个重要的组成部分：

1.  线程池大小：指线程池中所能容纳的最大线程数。线程池大小一般根据系统的负载情况和硬件资源来设置。
2.  工作队列：用于存放等待执行的任务。当线程池中的工作线程已经全部被占用时，新的任务将被加入到工作队列中等待执行。

### 线程池创建方式 ###

Java中线程池的创建方式主要有以下几种：

1.  使用 ThreadPoolExecutor 类手动创建：通过 ThreadPoolExecutor 类的构造函数自定义线程池的参数，包括核心线程数、最大线程数、线程存活时间、任务队列等。
2.  使用 Executors 类提供的工厂方法创建：通过 Executors 类提供的一些静态工厂方法创建线程池，例如 newFixedThreadPool、newSingleThreadExecutor、newCachedThreadPool 等。
3.  使用 Spring 框架提供的 ThreadPoolTaskExecutor 类：在 Spring 框架中可以通过 ThreadPoolTaskExecutor 类来创建线程池。

不同的创建方式适用于不同的场景，通常可以根据实际情况选择合适的方式创建线程池。手动创建 ThreadPoolExecutor 类可以灵活地配置线程池参数，但需要对线程池的各项参数有一定的了解；使用 Executors 工厂方法可以快速创建线程池，但可能无法满足特定的需求，且容易出现内存溢出的情况；而 Spring 框架提供的 ThreadPoolTaskExecutor 类则只能在 Spring 框架中使用。

### 线程池使用 ###

#### ThreadPoolExecutor 使用 ####

ThreadPoolExecutor 线程的创建与使用示例如下：

import java.util.concurrent.*;
    
    public class ThreadPoolDemo {
    
        public static void main(String[] args) {
            // 创建线程池
            ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2, // 核心线程数
                5, // 最大线程数
                60, // 线程池中线程的空闲时间（单位为秒）
                TimeUnit.SECONDS, // 时间单位
                new ArrayBlockingQueue<>(10) // 任务队列
            );
            // 提交任务
            for (int i = 1; i <= 20; i++) {
                final int taskId = i;
                executor.submit(() -> {
                    System.out.println("执行任务：" + taskId + "，线程名称：" + Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000); // 模拟任务执行时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }
            // 关闭线程池
            executor.shutdown();
        }
    }

在上面的示例中，我们通过 ThreadPoolExecutor 类手动创建了一个线程池，设置了线程池的核心线程数为 2，最大线程数为 5，线程空闲时间为 60 秒，任务队列为长度为 10 的 ArrayBlockingQueue。然后我们通过 submit() 方法向线程池中提交了 20 个任务，每个任务会在执行时输出自己的编号和执行线程的名称，然后睡眠1秒钟模拟任务执行时间。最后，我们调用 shutdown() 方法关闭线程池。

#### Executors 使用 ####

import java.util.concurrent.*;
    
    public class ExecutorsDemo {
        public static void main(String[] args) {
            // 创建线程池
            ExecutorService executor = Executors.newFixedThreadPool(5);
            // 提交任务
            for (int i = 1; i <= 10; i++) {
                final int taskId = i;
                executor.submit(() -> {
                    System.out.println("执行任务：" + taskId + "，线程名称：" + Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000); // 模拟任务执行时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }
            // 关闭线程池
            executor.shutdown();
        }
    }

在上面的示例中，我们使用了 Executors 工厂类中的 newFixedThreadPool() 方法创建了一个线程池，该线程池有 5 个固定线程。然后我们通过 submit() 方法向线程池中提交了 10 个任务，每个任务会在执行时输出自己的编号和执行线程的名称，然后睡眠 1 秒钟模拟任务执行时间。最后，我们调用 shutdown() 方法关闭线程池。值得注意的是，使用 Executors 工厂类创建线程池虽然非常简单，但是在实际生产环境中并不推荐，因为这种方式很容易导致线程资源被耗尽，从而影响系统的性能和稳定性。

#### ThreadPoolTaskExecutor 使用 ####

Spring 中 ThreadPoolTaskExecutor 的使用示例如下：

import java.util.concurrent.*;
    
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    public class ThreadPoolTaskExecutorDemo {
    
        public static void main(String[] args) {
            // 创建线程池
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(2); // 核心线程数
            executor.setMaxPoolSize(5); // 最大线程数
            executor.setQueueCapacity(10); // 任务队列长度
            executor.initialize();
            // 提交任务
            for (int i = 1; i <= 20; i++) {
                final int taskId = i;
                executor.submit(() -> {
                    System.out.println("执行任务：" + taskId + "，线程名称：" + Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000); // 模拟任务执行时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }
            // 关闭线程池
            executor.shutdown();
        }
    }

在上面的示例中，我们使用了 Spring 框架中的 ThreadPoolTaskExecutor 类创建了一个线程池，设置了线程池的核心线程数为 2，最大线程数为 5，任务队列长度为 10。然后我们通过 submit() 方法向线程池中提交了 20 个任务，每个任务会在执行时输出自己的编号和执行线程的名称，然后睡眠1秒钟模拟任务执行时间。最后，我们调用 shutdown() 方法关闭线程池。注意，在使用 Spring 框架中的 ThreadPoolTaskExecutor 类创建线程池时，我们需要先调用 initialize() 方法进行初始化。

> ThreadPoolTaskExecutor 底层还是通过 JDK 中提供的 ThreadPoolExecutor 类实现的。

### 线程池优点详解 ###

线程池相比于线程来说，它不需要频繁的创建和销毁线程，线程一旦创建之后，默认情况下就会一直保持在线程池中，等到有任务来了，再用这些已有的线程来执行任务，如下图所示：

![df9ac66c3aa2de92bc1385ae12ebe70c.png][]

#### 优点1：复用线程，降低资源消耗 ####

线程在创建时要开辟虚拟机栈、本地方法栈、程序计数器等私有线程的内存空间，而销毁时又要回收这些私有空间资源，如下图所示：

![7185aa286932594b59a92856e2ddfe02.png][]

而线程池创建了线程之后就会放在线程池中，因此线程池相比于线程来说，第一个优点就是**可以复用线程、减低系统资源的消耗**。

#### 优点2：提高响应速度 ####

线程池是复用已有线程来执行任务的，而线程是在有任务时才新建的，所以相比于线程来说，线程池能够更快的响应任务和执行任务。

#### 优点3：管控线程数和任务数 ####

线程池提供了更多的管理功能，这里管理功能主要体现在以下两个方面：

1.  控制最大并发数：线程池可以创建固定的线程数，从而避免了无限创建线程的问题。当线程创建过多时，会导致系统执行变慢，因为 CPU 核数是一定的、能同时处理的任务数也是一定的，而线程过多时就会造成线程恶意争抢和线程频繁切换的问题，从而导致程序执行变慢，所以合适的线程数才是高性能运行的关键。
2.  控制任务最大数：如果任务无限多，而内存又不足的情况下，就会导致程序执行报错，而线程池可以控制最大任务数，当任务超过一定数量之后，就会采用拒绝策略来处理多出的任务，从而保证了系统可以健康的运行。

#### 优点4：更多增强功能 ####

线程池相比于线程来说提供了更多的功能，比如定时执行和周期执行等功能。

### 小结 ###

线程池是一种管理和复用线程资源的机制。相比于线程，它具备四个主要优势：1.复用线程，降低了资源消耗；2.提高响应速度；3.提供了管理线程数和任务数的能力；4.更多增强功能。

[df9ac66c3aa2de92bc1385ae12ebe70c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/dbb2a56b535d4c659c6779702bfa7c4f.png
[7185aa286932594b59a92856e2ddfe02.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/e29166fe8df84ff583a58a9eacc82f24.png