IT评测·应用市场-qidao123.com

标题: 【Java 中创建线程池的方式】 [打印本页]

作者: 大连密封材料 时间: 2024-8-18 11:25
标题: 【Java 中创建线程池的方式】
以下是一些常见线程池的创建方式：
1. 使用ThreadPoolExecutor自定义创建线程池

这是企业中最推荐的做法，由于它提供了最大的机动性。
特性与特点：允许准确控制线程池的核心参数，如核心线程数、最大线程数、任务队列容量、线程空闲时间以及饱和计谋等。

import java.util.concurrent.*;
public class CustomThreadPool {
public static void main(String[] args) {
// 自定义线程池配置
int corePoolSize = 5; // 核心线程数
int maximumPoolSize = 10; // 最大线程数
long keepAliveTime = 60L; // 空闲线程存活时间
TimeUnit unit = TimeUnit.SECONDS; // 时间单位
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(20); // 任务队列
ThreadFactory threadFactory = Executors.defaultThreadFactory(); // 线程工厂
RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy(); // 拒绝策略
ExecutorService executor = new ThreadPoolExecutor(
corePoolSize,
maximumPoolSize,
keepAliveTime,
unit,
workQueue,
threadFactory,
handler
);
// 提交任务到线程池
for (int i = 0; i < 15; i++) {
executor.submit(() -> {
System.out.println("Task executed by " + Thread.currentThread().getName());
});
}
// 关闭线程池
executor.shutdown();
}
}

复制代码

核心参数：

corePoolSize：核心线程数。
maximumPoolSize：最大线程数。
keepAliveTime：空闲线程存活时间。
workQueue：任务队列，用于存储等待实行的任务。
threadFactory：线程工厂，用于创建新线程。
handler：拒绝计谋，当线程池无法处置处罚新任务时接纳的计谋。

实行任务流程

execute(Runnable command)：这是提交任务到线程池的主要方法。

实在行流程大致如下：

直接实行：假如当前运行的线程少于核心线程数，纵然其他线程是空闲的，也会尝试直接创建一个新的线程来实行任务。
参加队列：假如当前线程数等于核心线程数，任务将被放入工作队列中排队。
扩容线程池：假如工作队列已满，且当前线程数小于最大线程数，会创建新的线程来处置处罚任务。
拒绝计谋：假如当前线程数已经到达最大值，且工作队列也满了，就会触发拒绝计谋，通常是抛出非常或忽略该任务。

2. 使用Executors工厂方法

2.1. FixedThreadPool（固定大小线程池）

形貌: 创建一个固定大小的线程池，该线程池可重用固定数目的线程。假如所有线程都在活动状态，新提交的任务将在队列中等待，直到有线程可用。
特点：线程池大小固定，所有线程都会一直存在直到程序结束，适合于实行大量相似任务的场景。
使用场景：适用于负载较稳固的场景，尤其是当任务数和线程处置处罚能力相对均衡时。

public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}

复制代码

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixedThreadPoolExample {
public static void main(String[] args) {
// 创建一个固定大小为5的线程池
ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
final int taskId = i;
executor.execute(() -> {
System.out.println("Task ID " + taskId + " is running in " + Thread.currentThread().getName());
});
}
// 关闭线程池（最好在应用程序结束时执行）
executor.shutdown();
while (!executor.isTerminated()) {
// 等待所有任务完成
}
System.out.println("Finished all threads");
}
}

复制代码

2.2. CachedThreadPool（可缓存线程池）

形貌: 创建一个可根据必要创建新线程的线程池，线程池在必要时创建新线程，假如现有线程空闲超过60秒，则会被回收。
特点：线程池会根据必要创建新线程，假如有空闲线程则重用，否则新建。空闲线程在默认情况下存活60秒后被停止。
使用场景：适用于实行很多短期异步任务，如处置处罚HTTP哀求、实行短小的背景任务。

public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}

复制代码

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++) {
final int taskId = i;
executor.execute(() -> {
System.out.println("Task ID " + taskId + " is running in " + Thread.currentThread().getName());
});
}
executor.shutdown();
}
}

复制代码

2.3. SingleThreadExecutor（单线程线程池）

形貌: 创建一个只有一个线程的线程池，所有任务按照提交顺序依次实行。
特点：该线程池只使用一个线程来实行任务，任务按照提交顺序实行，适用于不必要并发但必要顺序处置处罚的场景。
使用场景：适用于必要保证顺序实行任务的场景，或作为背景任务处置处罚器。

public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}

复制代码

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 < 10; i++) {
final int taskId = i;
executor.execute(() -> {
System.out.println("Task ID " + taskId + " is running in " + Thread.currentThread().getName());
});
}
executor.shutdown();
}
}

复制代码

2.4. ScheduledThreadPool（定时/周期性任务线程池）

形貌: 创建一个支持定时及周期性实行任务的线程池。核心线程数固定，别的线程在无任务时会被回收。
特点：可以安排任务在未来的某个时间点实行，或者定期重复实行。适用于定时任务和周期性任务。
使用场景：实行定时任务，如定时数据同步、定时清理、定时查抄等。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}

复制代码

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(5);
Runnable task = () -> System.out.println("Task executed at " + System.currentTimeMillis());
// 延迟5秒后执行一次
executor.schedule(task, 5, TimeUnit.SECONDS);
// 每隔3秒执行一次
executor.scheduleAtFixedRate(task, 0, 3, TimeUnit.SECONDS);
// 在关闭前，通常应有逻辑来决定何时停止调度
// 这里为了简化，直接关闭线程池，但在实际应用中应避免立即关闭以免任务未完成
executor.shutdown();
while (!executor.isTerminated()) {}
System.out.println("Finished all scheduled tasks");
}
}

复制代码

底层实现
上述所有Executors工厂方法创建线程池的实现终极都基于ThreadPoolExecutor类，它内部维护了工作线程聚集、任务队列、同步控制锁等，以确保任务能够高效、安全地分配给线程实行，并处置处罚线程的生命周期管理、任务调理和拒绝计谋等题目。自定义配置线程池时，通过调解ThreadPoolExecutor的构造参数，可以针对特定应用场景优化性能和资源利用率。
特性总结

机动性: Executors提供的工厂方法简化了线程池的创建，使得开发者无需直接与ThreadPoolExecutor复杂的构造参数打交道。
易用性: 提供了多种预设的线程池模子，满意不同场景下的需求。
潜在风险: 只管方便，但直接使用这些方法可能会导致资源管理不当（如无限增长的队列、过多线程），因此现代实践中更推荐直接使用ThreadPoolExecutor举行定制化配置，以更好地控制和理解线程池的行为。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/)