【Java 基础篇】Executors工厂类详解

女爷i 2023-10-16 11:40 31阅读 0赞

![在这里插入图片描述][06ba6b2618084d6285afd14fd129186e.png]

在多线程编程中，线程池是一项重要的工具，它可以有效地管理和控制线程的生命周期，提高程序的性能和可维护性。Java提供了`java.util.concurrent`包来支持线程池的创建和管理，而`Executors`工厂类是其中的一部分，它提供了一些方便的方法来创建不同类型的线程池。本文将详细介绍`Executors`工厂类的使用方法和各种线程池的创建方式，以及一些注意事项和最佳实践。

### Executors工厂类概述 ###

`Executors`是Java中用于创建线程池的工厂类，它提供了一系列的静态工厂方法，用于创建不同类型的线程池。这些工厂方法隐藏了线程池的复杂性，使得线程池的创建变得非常简单。`Executors`工厂类提供的线程池有以下几种类型：

1.  **newCachedThreadPool()**：创建一个可缓存的线程池。这个线程池的线程数量可以根据需要自动扩展，如果有可用的空闲线程，就会重用它们；如果没有可用的线程，就会创建一个新线程。适用于执行大量的短期异步任务。
2.  **newFixedThreadPool(int nThreads)**：创建一个固定大小的线程池，其中包含指定数量的线程。线程数量是固定的，不会自动扩展。适用于执行固定数量的长期任务。
3.  **newSingleThreadExecutor()**：创建一个单线程的线程池。这个线程池中只包含一个线程，用于串行执行任务。适用于需要按顺序执行任务的场景。
4.  **newScheduledThreadPool(int corePoolSize)**：创建一个固定大小的线程池，用于定时执行任务。线程数量固定，不会自动扩展。适用于定时执行任务的场景。
5.  **newSingleThreadScheduledExecutor()**：创建一个单线程的定时执行线程池。只包含一个线程，用于串行定时执行任务。
6.  **newWorkStealingPool(int parallelism)**：创建一个工作窃取线程池，线程数量根据CPU核心数动态调整。适用于CPU密集型的任务。

接下来，我们将详细介绍每种类型线程池的创建和使用方法。

### newCachedThreadPool() ###

`newCachedThreadPool()`方法创建一个可缓存的线程池，这个线程池的特点是线程数量可以根据需要自动扩展，如果有可用的空闲线程，就会重用它们；如果没有可用的线程，就会创建一个新线程。这种线程池适用于执行大量的短期异步任务，例如一些需要快速响应的网络请求处理。

#### 创建方式 ####

ExecutorService executorService = Executors.newCachedThreadPool();

#### 使用示例 ####

public class CachedThreadPoolExample {
        
        public static void main(String[] args) {
        
            ExecutorService executorService = Executors.newCachedThreadPool();
    
            for (int i = 0; i < 10; i++) {
        
                final int taskId = i;
                executorService.submit(() -> {
        
                    System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                });
            }
    
            executorService.shutdown();
        }
    }

在上面的示例中，我们创建了一个可缓存的线程池，并提交了10个任务，线程池会根据需要自动创建新线程来执行这些任务。

### newFixedThreadPool(int nThreads) ###

`newFixedThreadPool(int nThreads)`方法创建一个固定大小的线程池，其中包含指定数量的线程。线程数量是固定的，不会自动扩展。这种线程池适用于执行固定数量的长期任务，例如服务器中的后台处理任务。

#### 创建方式 ####

int nThreads = 5; // 指定线程数量
    ExecutorService executorService = Executors.newFixedThreadPool(nThreads);

#### 使用示例 ####

public class FixedThreadPoolExample {
        
        public static void main(String[] args) {
        
            int nThreads = 3;
            ExecutorService executorService = Executors.newFixedThreadPool(nThreads);
    
            for (int i = 0; i < 10; i++) {
        
                final int taskId = i;
                executorService.submit(() -> {
        
                    System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                });
            }
    
            executorService.shutdown();
        }
    }

在上面的示例中，我们创建了一个固定大小为3的线程池，然后提交了10个任务。线程池会按顺序执行这些任务，每次最多有3个任务同时执行。

### newSingleThreadExecutor() ###

`newSingleThreadExecutor()`方法创建一个单线程的线程池，这个线程池中只包含一个线程，用于串行执行任务。这种线程池适用于需要按顺序执行任务的场景，例如一个任务队列中的任务需要依次执行。

#### 创建方式 ####

ExecutorService executorService = Executors.newSingleThreadExecutor();

#### 使用示例 ####

public class SingleThreadExecutorExample {
        
        public static void main(String[] args) {
        
            ExecutorService executorService = Executors.newSingleThreadExecutor();
    
            for (int i = 0; i < 10; i++) {
        
                final int taskId = i;
                executorService.submit(() -> {
        
                    System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                });
            }
    
            executorService.shutdown();
        }
    }

在上面的示例中，我们创建了一个单线程的线程池，并提交了10个任务。线程池会按顺序执行这些任务，保证每次只有一个任务在执行。

### newScheduledThreadPool(int corePoolSize) ###

`newScheduledThreadPool(int corePoolSize)`方法创建一个固定大小的线程池，用于定时执行任务。线程数量是固定的，不会自动扩展。这种线程池适用于需要定时执行任务的场景，例如定时任务调度。

#### 创建方式 ####

int corePoolSize = 2; // 指定线程数量
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(corePoolSize);

#### 使用示例 ####

import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    public class ScheduledThreadPoolExample {
        
        public static void main(String[] args) {
        
            int corePoolSize = 2;
            ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(corePoolSize);
    
            for (int i = 0; i < 3; i++) {
        
                final int taskId = i;
                scheduledExecutorService.schedule(() -> {
        
                    System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                }, i + 1, TimeUnit.SECONDS);
            }
    
            scheduledExecutorService.shutdown();
        }
    }

在上面的示例中，我们创建了一个固定大小为2的定时执行线程池，然后提交了3个定时任务，每个任务延迟执行的时间不同。

### newSingleThreadScheduledExecutor() ###

`newSingleThreadScheduledExecutor()`方法创建一个单线程的定时执行线程池，只包含一个线程，用于串行定时执行任务。

#### 创建方式 ####

ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();

#### 使用示例 ####

import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    public class SingleThreadScheduledExecutorExample {
        
        public static void main(String[] args) {
        
            ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
    
            for (int i = 0; i < 3; i++) {
        
                final int taskId = i;
                scheduledExecutorService.schedule(() -> {
        
                    System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                }, i + 1, TimeUnit.SECONDS);
            }
    
            scheduledExecutorService.shutdown();
        }
    }

在上面的示例中，我们创建了一个单线程的定时执行线程池，并提交了3个定时任务，每个任务延迟执行的时间不同。

### newWorkStealingPool(int parallelism) ###

`newWorkStealingPool(int parallelism)`方法创建一个工作窃取线程池，线程数量根据CPU核心数动态调整。这种线程池适用于CPU密集型的任务，可以充分利用多核CPU的性能。

#### 创建方式 ####

int parallelism = Runtime.getRuntime().availableProcessors(); // 获取CPU核心数
    ExecutorService executorService = Executors.newWorkStealingPool(parallelism);

#### 使用示例 ####

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    public class WorkStealingPoolExample {
        
        public static void main(String[] args) {
        
            int parallelism = Runtime.getRuntime().availableProcessors();
            ExecutorService executorService = Executors.newWorkStealingPool(parallelism);
    
            for (int i = 0; i < 10; i++) {
        
                final int taskId = i;
                executorService.submit(() -> {
        
                    System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
                });
            }
    
            executorService.shutdown();
        }
    }

在上面的示例中，我们根据CPU核心数创建了一个工作窃取线程池，并提交了10个任务。线程池会根据CPU核心数来动态调整线程数量，以充分利用CPU的性能。

### 总结 ###

`Executors`工厂类提供了多种线程池的创建方式，可以根据不同的需求选择合适的线程池类型。合理使用线程池可以提高程序的性能和可维护性，但也需要注意线程池的大小和资源管理，避免因线程过多导致的性能下降或资源耗尽问题。希望本文能够帮助读者更好地理解和使用`Executors`工厂类。

[06ba6b2618084d6285afd14fd129186e.png]: https://img-blog.csdnimg.cn/06ba6b2618084d6285afd14fd129186e.png