在 Java 中，Executor 和 ThreadPoolExecutor 是用于管理线程和执行任务的工具，帮助开发者更好地控制多线程环境。下面是它们的使用和区别。
1.Executor 简介
Executor 是一个接口，用来创建线程池，它定义了一个 execute(Runnable command) 方法，用于执行传递进来的任务。它是 Java 中线程池的基础。
但Executor是接口，并不能直接使用，所以还得需要实现类，图4-3中所示的内容就是完整的Executor接口相关的类继承结构。
对于简单的线程管理，使用 Executor 接口或 Executors 工具类创建的线程池通常足够。这些工具提供了一些便捷的方法来创建常见类型的线程池，如固定大小的线程池、单线程执行器和缓存线程池。以下是几个常见的例子：
1.)使用 Executors.newFixedThreadPool(int nThreads)
创建一个固定大小的线程池，适用于需要固定数量线程执行任务的场景。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixedThreadPoolExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(3); // 创建一个包含3个线程的固定线程池
for (int i = 0; i < 10; i++) {
executor.execute(new Task(i));
}
executor.shutdown(); // 关闭线程池，等待所有任务完成
}
}
class Task implements Runnable {
private int taskId;
public Task(int taskId) {
this.taskId = taskId;
}
@Override
public void run() {
System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());
}
}2) 使用 Executors.newSingleThreadExecutor()
创建一个单线程执行器，适用于需要按顺序执行任务的场景。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadExecutorExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newSingleThreadExecutor(); // 创建一个单线程执行器
for (int i = 0; i < 5; i++) {
executor.execute(new Task(i));
}
executor.shutdown(); // 关闭执行器，等待所有任务完成
}
}
class Task implements Runnable {
private int taskId;
public Task(int taskId) {
this.taskId = taskId;
}
@Override
public void run() {
System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());
}
}3.)使用 Executors.newCachedThreadPool()
创建一个缓存线程池，适用于短时间内需要大量并发、但不确定具体线程数量的场景。线程池会根据需要动态创建新线程，空闲线程超过60秒会被回收。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CachedThreadPoolExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newCachedThreadPool(); // 创建一个缓存线程池
for (int i = 0; i < 10; i++) {
executor.execute(new Task(i));
}
executor.shutdown(); // 关闭线程池，等待所有任务完成
}
}
class Task implements Runnable {
private int taskId;
public Task(int taskId) {
this.taskId = taskId;
}
@Override
public void run() {
System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());
}
}4) 使用 Executors.newScheduledThreadPool(int corePoolSize)
创建一个调度线程池，适用于需要周期性执行任务的场景。比如在固定的延迟后重复执行任务。
import java.util.concurrent.*;
public class ScheduledThreadPoolExample {
public static void main(String[] args) {
ScheduledExecutorService executor = Executors.newScheduledThreadPool(2); // 创建一个调度线程池
executor.scheduleAtFixedRate(new Task(1), 0, 2, TimeUnit.SECONDS); // 每2秒执行一次任务
// executor.shutdown(); // 通常不需要立即关闭调度线程池，除非你确认所有任务已经完成
}
}
class Task implements Runnable {
private int taskId;
public Task(int taskId) {
this.taskId = taskId;
}
@Override
public void run() {
System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());
}
}总结
• newFixedThreadPool：适合需要固定数量线程来执行大量并发任务的场景。
• newSingleThreadExecutor：适合任务必须顺序执行的场景。
• newCachedThreadPool：适合任务数量波动大且需要高并发的场景。
• newScheduledThreadPool：适合需要定时或周期性执行任务的场景。
这些工具类的简化了线程池的创建和管理，对于简单的线程管理场景，这些方法足够使用。
2. ThreadPoolExecutor 简介
ThreadPoolExecutor 是 Executor 接口的实现类，是 Java 中最灵活和可配置的线程池实现。它提供了丰富的配置选项，允许开发者自定义线程池的行为。
类ThreadPoolExecutor的方法列表:
构造函数：
ThreadPoolExecutor 的构造函数允许你设置以下参数：
• corePoolSize: 核心线程数，当任务数量少于这个数目时，即使有空闲线程也不会被回收。
• maximumPoolSize: 最大线程数，表示线程池中允许存在的最大线程数。
• keepAliveTime: 当线程数量超过核心线程数时，多余空闲线程的存活时间。
• unit: keepAliveTime 的时间单位。
• workQueue: 用于保存等待执行任务的队列。
• threadFactory: 用于创建新线程的工厂。
• handler: 当任务无法被执行时的处理器。
使用示例：
import java.util.concurrent.*;
public class ThreadPoolExecutorExample {
public static void main(String[] args) {
int corePoolSize = 2;
int maximumPoolSize = 4;
long keepAliveTime = 10;
TimeUnit unit = TimeUnit.SECONDS;
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(2);
ThreadPoolExecutor executor = new ThreadPoolExecutor(
corePoolSize,
maximumPoolSize,
keepAliveTime,
unit,
workQueue,
new ThreadPoolExecutor.CallerRunsPolicy() // 当线程池满时的策略
);
for (int i = 0; i < 10; i++) {
executor.execute(new Task(i));
}
executor.shutdown();
}
}
class Task implements Runnable {
private int taskId;
public Task(int taskId) {
this.taskId = taskId;
}
@Override
public void run() {
System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());
try {
Thread.sleep(2000); // 模拟任务执行
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}解释
1. 创建 ThreadPoolExecutor：
• 我们创建了一个线程池，核心线程数为2，最大线程数为4，使用一个容量为2的阻塞队列来保存任务。
• 当线程池中线程数超过 corePoolSize 时，空闲线程会在 keepAliveTime 时间内存活。
2. 提交任务：
• 向线程池提交了10个任务。根据配置，最开始会创建2个核心线程，处理任务。接着会放入阻塞队列中，当队列满了之后，会创建新线程处理任务，直到达到 maximumPoolSize。如果线程池和队列都满了，则会执行指定的拒绝策略。
3. 拒绝策略：
• 这里使用 CallerRunsPolicy，当线程池和队列都满时，任务会在调用 execute 的线程中执行。
4. 关闭线程池：
• 使用 shutdown() 方法来关闭线程池，确保所有已提交的任务都会执行完毕。
总结
• Executor: 是一个更简单的接口，用于任务的执行，但提供的功能有限。
• ThreadPoolExecutor: 是一个更高级的实现，允许对线程池的大小、任务队列、线程超时、线程创建工厂等进行更详细的控制，适合需要高度自定义线程池行为的场景。
对于简单的线程管理，Executor 或使用 Executors 工具类创建的线程池足够了。但如果你需要更复杂的线程池管理，ThreadPoolExecutor 是一个强大的工具。
