目录
3. SingleThreadExecutor（单线程线程池）
4. ScheduledThreadPool（定时任务线程池）
一.Java内部封装的四种线程池
在Java中，
java.util.concurrent包提供了四种常见的内置线程池，分别是FixedThreadPool、CachedThreadPool、SingleThreadExecutor和ScheduledThreadPool。下面我将分别详细讲解这四种线程池的特点、参数以及适用场景，并为每种线程池举例说明。
1. FixedThreadPool（固定大小线程池）
特点：该线程池的线程数量是固定的，不会随着任务数量的增加而改变。
参数：需要指定固定的线程数量。
适用场景：适用于需要限制并发线程数量的情况，比如服务器端对客户端的请求服务。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixedThreadPoolExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(3);
for (int i = 1; i <= 5; i++) {
final int taskID = i;
executor.submit(new Runnable() {
public void run() {
System.out.println("Task " + taskID + " is running in thread: " + Thread.currentThread().getName());
}
});
}
executor.shutdown();
}
}
上述代码用固定线程池的示例。它创建了一个大小为3的固定线程池，并向线程池提交了5个任务。每个任务都打印出任务ID和执行该任务的线程名,在代码中，我们使用
ExecutorService接口表示线程池，通过Executors.newFixedThreadPool(3)方法创建一个固定大小为3的线程池实例。然后，我们使用一个循环提交5个任务到线程池中。每个任务都是一个Runnable对象，其中的run()方法定义了具体的任务逻辑，即打印任务ID和执行线程的名称。最后，我们调用shutdown()方法来关闭线程池，这会使得线程池不再接受新的任务，并且等待所有已提交的任务执行完毕后终止。这种使用固定线程池的方式可以限制线程的数量，适用于执行较长时间的任务，以避免创建过多线程导致资源浪费。
2. CachedThreadPool（可缓存线程池）
特点：线程数量不固定，会根据任务数动态调整线程数量。
参数：不需要指定线程数量。
适用场景：适用于执行大量短期异步任务的情况，比如一些耗时较短的操作
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 = 1; i <= 5; i++) {
final int taskID = i;
executor.submit(new Runnable() {
public void run() {
System.out.println("Task " + taskID + " is running in thread: " + Thread.currentThread().getName());
}
});
}
executor.shutdown();
}
}
首先，通过调用 `Executors.newCachedThreadPool()` 方法，我们创建了一个 `CachedThreadPool`。这种类型的线程池会根据需要自动创建新的线程，并在一段时间后自动回收空闲线程。
接下来，通过一个循环，我们向线程池提交了五个任务。每个任务都是一个实现了 `Runnable` 接口的匿名内部类，其中的 `run()` 方法定义了任务要执行的操作。
在每个任务的 `run()` 方法中，我们打印了当前任务的 ID（`taskID`）以及运行该任务的线程的名称（`Thread.currentThread().getName()`）。
最后，我们调用了 `executor.shutdown()` 方法来关闭线程池。这将阻止线程池接受新的任务，并等待已提交的任务完成执行。
3. SingleThreadExecutor（单线程线程池）
特点：只有一个工作线程的线程池，保证所有任务按照指定顺序执行。
参数：不需要指定线程数量。
适用场景：适用于需要顺序执行任务、并且在任务执行过程中需要依赖上一个任务结果的情况
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 = 1; i <= 5; i++) {
final int taskID = i;
executor.submit(new Runnable() {
public void run() {
System.out.println("Task " + taskID + " is running in thread: " + Thread.currentThread().getName());
}
});
}
executor.shutdown();
}
}
首先，通过调用 `Executors.newSingleThreadExecutor()` 方法，我们创建了一个 `SingleThreadExecutor`。这种类型的线程池只会创建一个单独的线程来执行所有的任务。如果该线程在执行任务时发生异常而终止，线程池会创建一个新的线程来替代它。
接下来，通过一个循环，我们向线程池提交了五个任务。每个任务都是一个实现了 `Runnable` 接口的匿名内部类，其中的 `run()` 方法定义了任务要执行的操作。在每个任务的 `run()` 方法中，我们打印了当前任务的 ID（`taskID`）以及运行该任务的线程的名称（`Thread.currentThread().getName()`）。
4. ScheduledThreadPool（定时任务线程池）
特点：用于执行定时任务和周期性任务的线程池。
参数：需要指定线程数量。
适用场景：适用于需要定期执行任务的情况，比如定时备份、定时统计等。
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledThreadPoolExample {
public static void main(String[] args) {
ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
for (int i = 1; i <= 5; i++) {
final int taskID = i;
executor.schedule(new Runnable() {
public void run() {
System.out.println("Task " + taskID + " is running in thread: " + Thread.currentThread().getName());
}
}, 3, TimeUnit.SECONDS);
}
executor.shutdown();
}
}
这段代码创建了一个定时线程池，并且使用`schedule()`方法提交了5个任务，每个任务都会在3秒后执行。任务会打印出任务ID和执行线程的名称。
二.手动创建ThreadPoolExecutor
七大核心参数
在使用`ThreadPoolExecutor`创建线程池时，有七个核心参数需要注意。下面是对这些参数的详细讲解：
1. `corePoolSize`（核心线程数）：指定线程池中保持活动状态的线程数，即使它们处于空闲状态。当有新任务提交时，线程池会优先创建核心线程来处理任务。
2. `maximumPoolSize`（最大线程数）：指定线程池中允许存在的最大线程数。当工作队列已满且当前线程数小于最大线程数时，线程池会创建新的线程来处理任务。如果达到最大线程数并且工作队列也已满，则后续提交的任务将根据配置的拒绝策略进行处理。
3. `keepAliveTime`（线程空闲时间）：指定非核心线程的最大空闲时间，超过这个时间就会被回收销毁，只保留核心线程数。
4. `unit`（时间单位）：用于设置`keepAliveTime`的时间单位，例如`TimeUnit.SECONDS`表示秒。
5. `workQueue`（工作队列）：用于存储等待执行的任务的阻塞队列。当所有核心线程都在工作且工作队列已满时，新任务将被放入工作队列中等待执行。
ArrayBlockingQueue：一个由数组实现的有界阻塞队列。LinkedBlockingQueue：一个由链表实现的可选有界阻塞队列。SynchronousQueue：一个没有数据缓冲区的阻塞队列，每个插入操作必须等待另一个线程的相应删除操作，反之亦然。PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。
6. `threadFactory`（线程工厂）：用于创建新线程的工厂类。可以自定义线程工厂来为线程池中的每个线程设置特定的名称、优先级等。
7. `handler`（拒绝策略）：当线程池已经达到最大线程数并且工作队列也已满时，新任务将根据拒绝策略进行处理。常见的拒绝策略有四种：
- `ThreadPoolExecutor.AbortPolicy`：默认策略，抛出`RejectedExecutionException`异常。
- `ThreadPoolExecutor.CallerRunsPolicy`：由调用线程处理该任务。
- `ThreadPoolExecutor.DiscardPolicy`：直接丢弃任务，不抛出异常。
- `ThreadPoolExecutor.DiscardOldestPolicy`：丢弃等待时间最长的任务，然后尝试提交新的任务。。
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExample {
public static void main(String[] args) {
// 创建一个线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, 5,
10, TimeUnit.SECONDS,
new LinkedBlockingQueue<>()
);
// 添加任务到线程池
for (int i = 0; i < 10; i++) {
final int taskId = i;
executor.execute(new Runnable() {
@Override
public void run() {
System.out.println("Task " + taskId + " is running.");
}
});
}
// 关闭线程池
executor.shutdown();
}
}
使用
ThreadPoolExecutor类手动创建一个线程池。通过传递不同的参数，我们可以控制线程池的行为，例如线程池的最小/最大线程数、空闲线程的最大存活时间、等待队列的类型等。然后，我们向线程池提交任务，每个任务都是实现了Runnable接口的匿名内部类，它们会打印任务ID。在这个例子中，我们向线程池提交了10个任务。
1525
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
