在Java中,Executors 类提供了多种静态工厂方法来创建不同类型的线程池。在学习线程池的过程中,一定避不开Executors类,掌握这个类的使用、原理、使用场景,对于实际项目开发时,运用自如,以下是一些常用的方法,来一一细说:
-
newCachedThreadPool()
: 创建一个可缓存的线程池,如果线程池中的线程超过60秒没有被使用,它们将被终止并从缓存中移除。 -
newFixedThreadPool(int nThreads)
: 创建一个固定大小的线程池,其中 nThreads 指定了线程池中线程的数量。 -
newSingleThreadExecutor()
: 创建一个单线程的执行器,它创建单个工作线程来执行任务。 -
newScheduledThreadPool(int corePoolSize)
: 创建一个固定大小的线程池,它可以根据需要创建新线程,但会按照固定延迟执行具有给定初始延迟的任务。 -
newWorkStealingPool(int parallelism)
: 创建一个工作窃取线程池,它使用多个队列,每个线程都从自己的队列中窃取任务。 -
newSingleThreadScheduledExecutor()
: 创建一个单线程的调度执行器,它可以根据需要创建新线程来执行任务。 -
privilegedThreadFactory()
: 创建一个线程工厂,用于创建具有特权访问的线程。 -
defaultThreadFactory()
: 创建一个默认的线程工厂,用于创建具有非特权访问的线程。 -
unconfigurableExecutorService(ExecutorService executor)
: 将给定的 ExecutorService 转换为不可配置的版本,这样调用者就不能修改它的配置。
这些方法提供了灵活的方式来创建和管理线程池,以满足不同的并发需求,下面 V 哥来一一介绍一下9个方法的实现以及使用场景。
1. newCachedThreadPool()
newCachedThreadPool 方法是 Java java.util.concurrent 包中的 Executors 类的一个静态工厂方法。这个方法用于创建一个可缓存的线程池,它能够根据需要创建新线程,并且当线程空闲超过一定时间后,线程会被终止并从线程池中移除。
下面是 newCachedThreadPool 方法的大致实现原理和源代码分析:
实现原理
-
线程创建: 当提交任务到线程池时,如果线程池中的线程数少于核心线程数,会创建新的线程来执行任务。
-
线程复用: 如果线程池中的线程数已经达到核心线程数,新提交的任务会被放入任务队列中等待执行。
-
线程回收: 如果线程池中的线程在一定时间内(默认是60秒)没有任务执行,它们会被终止,从而减少资源消耗。
源代码分析
在 Java 的 java.util.concurrent 包中,Executors 类并没有直接提供 newCachedThreadPool 的实现,而是通过调用 ThreadPoolExecutor 类的构造函数来实现的。以下是 ThreadPoolExecutor 构造函数的调用示例:
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
参数解释:
-
corePoolSize: 核心线程数,这里设置为0,表示线程池不会保留任何核心线程。
-
maximumPoolSize: 最大线程数,这里设置为 Integer.MAX_VALUE,表示理论上可以创建无限多的线程。
-
keepAliveTime: 当线程数大于核心线程数时,多余的空闲线程能等待新任务的最长时间,这里设置为60秒。
-
unit: keepAliveTime 参数的时间单位,这里是秒。
-
workQueue: 一个任务队列,这里使用的是 SynchronousQueue,它是一个不存储元素的阻塞队列,每个插入操作必须等待一个相应的移除操作。
实现过程
-
初始化: 当调用 newCachedThreadPool 时,会创建一个 ThreadPoolExecutor 实例。
-
任务提交: 当任务提交给线程池时,线程池会检查是否有空闲线程可以立即执行任务。
-
线程创建: 如果没有空闲线程,并且当前线程数小于 maximumPoolSize,则创建新线程执行任务。
-
任务队列: 如果当前线程数已经达到 maximumPoolSize,则将任务放入 SynchronousQueue 中等待。
-
线程复用: 当一个线程执行完任务后,它不会立即终止,而是尝试从 SynchronousQueue 中获取新任务。
-
线程回收: 如果线程在 keepAliveTime 时间内没有获取到新任务,它将被终止。
这种设计使得 newCachedThreadPool 非常适合处理大量短生命周期的任务,因为它可以动态地调整线程数量以适应任务负载的变化。然而,由于它可以创建无限多的线程,如果没有适当的任务队列来控制任务的数量,可能会导致资源耗尽。因此,在使用 newCachedThreadPool 时,需要谨慎考虑任务的特性和系统的资源限制。
使用场景:
适用于执行大量短期异步任务,尤其是任务执行时间不确定的情况。例如,Web服务器处理大量并发请求,或者异步日志记录。
2. newFixedThreadPool(int nThreads)
newFixedThreadPool(int nThreads) 是 Java 中 java.util.concurrent 包的 Executors 类的一个静态工厂方法。这个方法用于创建一个固定大小的线程池,它能够确保线程池中始终有固定数量的线程在工作。
以下是 newFixedThreadPool 方法的实现原理、源代码分析以及实现过程:
实现原理
-
固定线程数: 线程池中的线程数量始终保持为 nThreads。
-
任务队列: 提交的任务首先由核心线程执行,如果核心线程都在忙碌状态,新任务将被放入一个阻塞队列中等待执行。
-
线程复用: 线程池中的线程会重复利用,执行完一个任务后,会立即尝试从队列中获取下一个任务执行。
源代码分析
newFixedThreadPool 方法是通过调用 ThreadPoolExecutor 类的构造函数来实现的。以下是 ThreadPoolExecutor 构造函数的调用示例:
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(
nThreads, // 核心线程数
nThreads, // 最大线程数
0L, // 线程空闲时间,这里设置为0,表示线程不会空闲
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>() // 使用阻塞队列来存储任务
);
}
参数解释:
-
corePoolSize: 核心线程数,这里设置为 nThreads,表示线程池中始终有 nThreads 个线程。
-
maximumPoolSize: 最大线程数,这里也设置为 nThreads,表示线程池的线程数量不会超过 nThreads。
-
keepAliveTime: 当线程数大于核心线程数时,多余的空闲线程能等待新任务的最长时间,这里设置为0,表示如果线程池中的线程数超过核心线程数,这些线程将立即终止。
-
unit: keepAliveTime 参数的时间单位,这里是毫秒。
-
workQueue: 一个任务队列,这里使用的是 LinkedBlockingQueue,它是一个基于链表的阻塞队列,可以存储任意数量的任务。
实现过程
-
初始化: 当调用 newFixedThreadPool 时,会创建一个 ThreadPoolExecutor 实例。
-
任务提交: 当任务提交给线程池时,线程池会检查是否有空闲的核心线程可以立即执行任务。
-
任务队列: 如果所有核心线程都在忙碌状态,新提交的任务将被放入 LinkedBlockingQueue 中等待。
-
线程复用: 核心线程执行完一个任务后,会尝试从 LinkedBlockingQueue 中获取新任务继续执行。
-
线程数量控制: 由于 keepAliveTime 设置为0,当线程池中的线程数超过核心线程数时,这些线程会立即终止,从而保证线程池中的线程数量不会超过 nThreads。
这种设计使得 newFixedThreadPool 非常适合处理大量且持续的任务,因为它可以保证任务以固定的线程数量并行执行,同时避免了线程数量的无限制增长。然而,由于线程池的大小是固定的,如果任务提交的速率超过了线程池的处理能力,可能会导致任务在队列中等待较长时间。因此,在使用 newFixedThreadPool 时,需要根据任务的特性和预期的负载来合理设置 nThreads 的值。
使用场景:
适用于执行大量长期运行的任务,其中线程数量需要固定。例如,同时运行多个数据加载或数据处理任务,且希望限制并发数以避免资源过载。
3. newSingleThreadExecutor()
newSingleThreadExecutor 是 Java 中 java.util.concurrent 包的 Executors 类的一个静态工厂方法,用于创建一个单线程的执行器。这个执行器确保所有任务都按照任务提交的顺序,在一个线程中顺序执行。
以下是 newSingleThreadExecutor 方法的实现原理、源代码分析以及实现过程:
实现原理
-
单线程执行: 线程池中只有一个线程,所有任务都由这个线程顺序执行。
-
任务队列: 如果这个线程在执行任务时有新任务提交,新任务会被放入一个阻塞队列中等待执行。
-
线程复用: 这个线程会重复利用,执行完一个任务后,会立即尝试从队列中获取下一个任务执行。
源代码分析
newSingleThreadExecutor 方法同样是通过调用 ThreadPoolExecutor 类的构造函数来实现的。以下是 ThreadPoolExecutor 构造函数的调用示例:
public static ExecutorService newSingleThreadExecutor() {
return new ThreadPoolExecutor(
1, // 核心线程数
1, // 最大线程数
0L, TimeUnit.MILLISECONDS, // 线程空闲时间,这里设置为0,表示线程不会空闲
new LinkedBlockingQueue<Runnable>() // 使用阻塞队列来存储任务
);
}
参数解释:
-
corePoolSize: 核心线程数,这里设置为1,表示线程池中始终有一个核心线程。
-
maximumPoolSize: 最大线程数,这里也设置为1,表示线程池的线程数量不会超过1。
-
keepAliveTime: 线程空闲时间,这里设置为0,表示如果线程空闲,它将立即终止。
-
unit: keepAliveTime 参数的时间单位,这里是毫秒。
-
workQueue: 一个任务队列,这里使用的是 LinkedBlockingQueue,它是一个无界队列,可以存储任意数量的任务。
实现过程
-
初始化: 当调用 newSingleThreadExecutor 时,会创建一个 ThreadPoolExecutor 实例。
-
任务提交: 当任务提交给线程池时,如果核心线程空闲,则立即执行任务;如果核心线程忙碌,则将任务放入 LinkedBlockingQueue 中等待。
-
顺序执行: 由于只有一个线程,所有任务都将按照提交的顺序被执行。
-
任务队列: 如果核心线程在执行任务,新提交的任务将被放入 LinkedBlockingQueue 中排队等待。
-
线程复用: 核心线程执行完一个任务后,会尝试从 LinkedBlockingQueue 中获取新任务继续执行。
-
线程数量控制: 由于 keepAliveTime 设置为0,核心线程在没有任务执行时会立即终止。但由于 corePoolSize 和 maximumPoolSize 都为1,线程池会立即重新创建一个线程。
这种设计使得 newSingleThreadExecutor 非常适合处理需要保证任务顺序的场景,例如,当任务之间有依赖关系或者需要按照特定顺序执行时。同时,由于只有一个线程,这也避免了多线程环境下的并发问题。然而,由于只有一个线程执行任务,这也限制了并行处理的能力,如果任务执行时间较长,可能会导致后续任务等待较长时间。因此,在使用 newSingleThreadExecutor 时,需要根据任务的特性和对顺序的要求来决定是否适用。
使用场景:
适用于需要保证任务顺序执行的场景,例如,顺序处理队列中的消息或事件。也适用于需要单个后台线程持续处理周期性任务的情况。
4. newScheduledThreadPool(int corePoolSize)
newScheduledThreadPool 是 Java 中 java.util.concurrent 包的 Executors 类的一个静态工厂方法,用于创建一个固定大小的线程池,这个线程池支持定时以及周期性的任务执行。
以下是 newScheduledThreadPool 方法的实现原理、源代码分析以及实现过程:
实现原理
-
定时任务: 线程池能够按照指定的延迟执行任务,或者以固定间隔周期性地执行任务。
-
固定线程数: 线程池中的线程数量被限制为 corePoolSize 指定的大小。
-
任务队列: 任务首先由核心线程执行,如果核心线程都在忙碌状态,新任务将被放入一个延迟任务队列中等待执行。
源代码分析
newScheduledThreadPool 方法是通过调用 ScheduledThreadPoolExecutor 类的构造函数来实现的。以下是 ScheduledThreadPoolExecutor 构造函数的调用示例:
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
这里的 ScheduledThreadPoolExecutor 是 ThreadPoolExecutor 的一个子类,专门为执行定时任务设计。ScheduledThreadPoolExecutor 构造函数的参数 corePoolSize 定义了线程池中核心线程的数量。
ScheduledThreadPoolExecutor 内部使用了一个 DelayedWorkQueue 作为任务队列,这个队列能够按照任务的预定执行时间对任务进行排序。
实现过程
-
初始化: 当调用 newScheduledThreadPool 时,会创建一个 ScheduledThreadPoolExecutor 实例。
-
任务提交: 当任务提交给线程池时,线程池会根据任务的预定执行时间,将任务放入 DelayedWorkQueue 中。
-
任务调度: 线程池中的线程会从 DelayedWorkQueue 中获取任务,如果任务的执行时间已经到达,线程将执行该任务。
-
线程复用: 执行完一个任务的线程会再次尝试从 DelayedWorkQueue 中获取下一个任务。
-
线程数量控制: 如果任务队列中的任务数量超过了核心线程能够处理的范围,ScheduledThreadPoolExecutor 会创建新的线程来帮助处理任务,直到达到 corePoolSize 指定的最大线程数。
特点
-
ScheduledThreadPoolExecutor 允许设置一个线程工厂,用于创建具有特定属性的线程。
-
它还允许设置一个 RejectedExecutionHandler,当任务无法被接受时(例如,线程池关闭或任务队列已满),这个处理器会被调用。
-
与 ThreadPoolExecutor 不同,ScheduledThreadPoolExecutor 的 shutdown 和 shutdownNow 方法不会等待延迟任务执行完成。
使用 newScheduledThreadPool 创建的线程池非常适合需要执行定时任务的场景,例如,定期执行的后台任务、定时检查等。然而,由于它是基于固定大小的线程池,所以在高负载情况下,任务可能会排队等待执行,这需要在设计时考虑适当的 corePoolSize 以满足性能要求。
使用场景:
适用于需要定期执行任务或在将来某个时间点执行任务的场景。例如,定时备份数据、定时发送提醒等。
5. newWorkStealingPool(int parallelism)
newWorkStealingPool 是 Java 8 中新增的 java.util.concurrent 包的 Executors 类的一个静态工厂方法。这个方法用于创建一个工作窃取(Work-Stealing)线程池,它能够提高并行任务的执行效率,特别是在多处理器系统上。
实现原理
-
工作窃取: 在工作窃取线程池中,每个线程都有自己的任务队列。当一个线程完成自己的任务后,它会尝试从其他线程的任务队列中“窃取”任务来执行。
-
并行级别: 线程池的大小由 parallelism 参数决定,这个参数通常等于主机上的处理器核心数。
-
动态调整: 工作窃取线程池可以动态地添加或移除线程,以适应任务的负载和线程的利用率。
源代码分析
newWorkStealingPool 方法是通过调用 ForkJoinPool 类的静态工厂方法 commonPoolFor 来实现的。以下是 ForkJoinPool 构造函数的调用示例:
public static ExecutorService newWorkStealingPool(int parallelism) {
return new ForkJoinPool(
parallelism,
ForkJoinPool.defaultForkJoinWorkerThreadFactory,
null, // 没有未处理的异常处理器
false // 不是一个异步任务
);
}
参数解释:
-
parallelism: 线程池的并行级别,即线程池中的线程数量。
-
ForkJoinPool.defaultForkJoinWorkerThreadFactory: 默认的线程工厂,用于创建线程。
-
null: 未处理的异常处理器,这里没有指定,因此如果任务抛出未捕获的异常,它将被传播到 ForkJoinTask 的调用者。
-
false: 表示这不是一个异步任务。
ForkJoinPool 内部使用了 ForkJoinWorkerThread 来执行任务,并且每个线程都有一个 ForkJoinQueue 来存储任务。
实现过程
-
初始化: 当调用 newWorkStealingPool 时,会创建一个 ForkJoinPool 实例。
-
任务提交: 当任务提交给线程池时,它们会被放入调用线程的本地队列中。
-
任务执行: 每个线程首先尝试执行其本地队列中的任务。
-
工作窃取: 如果本地队列为空,线程会尝试从其他线程的队列中窃取任务来执行。
-
动态调整: 线程池可以根据需要动态地添加或移除线程。
特点
-
工作窃取线程池特别适合于工作量不均匀分布的任务,因为它可以减少空闲时间并提高资源利用率。
-
它也适用于可分解为多个子任务的并行计算任务,因为可以将任务分解后,再将子任务提交给线程池。
-
由于每个线程都有自己的队列,因此减少了锁的争用,提高了并发性能。
使用 newWorkStealingPool 创建的线程池非常适合于需要高并发和高吞吐量的场景,尤其是在多处理器系统上。然而,由于工作窃取机制,它可能不适用于任务执行时间非常短或者任务数量非常少的场景,因为窃取任务本身可能会引入额外的开销。
使用场景:
适用于工作量不均匀或可分解为多个小任务的并行计算任务。例如,图像处理、数据分析等,可以在多核处理器上有效利用所有核心。
6. newSingleThreadScheduledExecutor()
newSingleThreadScheduledExecutor 是 Java 中 java.util.concurrent 包的 Executors 类的一个静态工厂方法。这个方法用于创建一个单线程的调度执行器,它可以安排命令在给定的延迟后运行,或者定期地执行。
以下是 newSingleThreadScheduledExecutor 方法的实现原理、源代码分析以及实现过程:
实现原理
-
单线程执行: 执行器确保所有任务都在单个线程中顺序执行,这保证了任务的执行顺序。
-
定时任务: 支持延迟执行和周期性执行任务。
-
任务队列: 所有任务首先被放入一个任务队列中,然后由单线程按顺序执行。
源代码分析
newSingleThreadScheduledExecutor 方法是通过调用 ScheduledThreadPoolExecutor 类的构造函数来实现的。以下是 ScheduledThreadPoolExecutor 构造函数的调用示例:
public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
return new ScheduledThreadPoolExecutor(1);
}
这里,ScheduledThreadPoolExecutor 是 ExecutorService 的一个实现,专门为执行定时任务设计。构造函数只有一个参数,即核心线程数,这里设置为1,表示这是一个单线程的执行器。
ScheduledThreadPoolExecutor 内部使用了一个 DelayedWorkQueue 作为任务队列,这个队列能够按照任务的预定执行时间对任务进行排序。
实现过程
-
初始化: 当调用 newSingleThreadScheduledExecutor 时,会创建一个 ScheduledThreadPoolExecutor 实例,其核心线程数为1。
-
任务提交: 当任务提交给执行器时,任务会被封装成 ScheduledFutureTask 或者 RunnableScheduledFuture,然后放入 DelayedWorkQueue 中。
-
任务调度: 单线程会不断地从 DelayedWorkQueue 中获取任务,并按照预定的时间执行。如果任务的执行时间已经到达,任务将被执行;如果还没有到达,线程会等待直到执行时间到来。
-
顺序执行: 由于只有一个线程,所有任务都将按照它们被提交的顺序被执行。
-
周期性任务: 对于需要周期性执行的任务,执行器会在每次任务执行完毕后,重新计算下一次执行的时间,并再次将任务放入队列。
特点
-
newSingleThreadScheduledExecutor 创建的执行器非常适合需要保证任务顺序的场景,例如,需要按照特定顺序执行的任务或者具有依赖关系的任务。
-
它也适合执行定时任务,如定期执行的维护任务或者后台任务。
-
由于只有一个线程,这也避免了多线程环境下的并发问题,简化了任务同步和状态管理。
使用 newSingleThreadScheduledExecutor 创建的执行器可以提供强大的定时任务功能,同时保持任务执行的顺序性。然而,由于只有一个线程执行任务,这也限制了并行处理的能力,如果任务执行时间较长,可能会导致后续任务等待较长时间。因此,在使用 newSingleThreadScheduledExecutor 时,需要根据任务的特性和对顺序的要求来决定是否适用。
使用场景:
适用于需要单个后台线程按计划执行任务的场景。例如,定时检查系统状态、定时执行维护任务等。
7. privilegedThreadFactory()
privilegedThreadFactory 是 Java 中 java.util.concurrent 包的 Executors 类的一个静态工厂方法,用于创建一个线程工厂,该工厂能够产生具有特权访问的线程。这意味着这些线程可以加载系统属性和库,并且可以访问文件系统。
以下是 privilegedThreadFactory 方法的实现原理、源代码分析以及实现过程:
实现原理
-
特权访问: 创建的线程将具有访问系统资源的权限,例如,加载系统属性和库。
-
线程创建: 线程工厂将创建新的线程实例,这些线程实例将继承创建它们的线程的上下文。
源代码分析
在 Java 的标准库中,privilegedThreadFactory 方法的实现细节并未公开,因为它是一个私有方法。然而,我们可以分析其大致工作原理。privilegedThreadFactory 方法的调用示例如下:
public static ThreadFactory privilegedThreadFactory() {
return new PrivilegedThreadFactory();
}
这里,PrivilegedThreadFactory 是 Executors 类的一个私有静态内部类,它实现了 ThreadFactory 接口。ThreadFactory 接口定义了一个 newThread(Runnable r) 方法,用于创建新的线程。
实现过程
-
初始化: 当调用 privilegedThreadFactory 方法时,会返回一个新的 PrivilegedThreadFactory 实例。
-
线程创建: 当使用这个工厂创建线程时,它会调用 newThread(Runnable r) 方法。
-
特权访问: 在 newThread(Runnable r) 方法的实现中,会使用 AccessController.doPrivileged 方法来确保新创建的线程具有特权访问。
-
上下文复制: 通常,新线程会复制创建它的线程的上下文,包括类加载器等。
示例代码
虽然我们不能查看 privilegedThreadFactory 的具体实现,但是我们可以提供一个示例实现,以展示如何创建具有特权访问的线程:
public class PrivilegedThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable r) {
return AccessController.doPrivileged(new PrivilegedAction<>() {
@Override
public Thread run() {
return new Thread(r);
}
});
}
}
在这个示例中,PrivilegedAction 是一个实现了 PrivilegedAction<T>
接口的匿名类,其 run 方法创建了一个新的线程。AccessController.doPrivileged 方法用于执行一个特权操作,这里是为了确保线程创建过程中具有必要的权限。
特点
-
使用 privilegedThreadFactory 创建的线程可以在需要访问敏感系统资源的情况下使用。
-
这种线程工厂通常用于需要执行特权操作的应用程序,例如,访问系统属性或者执行文件 I/O 操作。
使用 privilegedThreadFactory 可以确保线程在执行任务时具有适当的安全权限,从而避免安全异常。然而,需要注意的是,过度使用特权访问可能会带来安全风险,因此在设计应用程序时应谨慎使用。
使用场景:
适用于需要线程具有更高权限来访问系统资源的场景。例如,需要访问系统属性或执行文件I/O操作的应用程序。
8. defaultThreadFactory()
defaultThreadFactory 是 Java 中 java.util.concurrent 包的 Executors 类的一个静态工厂方法,用于创建一个默认的线程工厂。这个线程工厂生成的线程没有特殊的权限,它们是普通的线程,具有标准的访问权限。
以下是 defaultThreadFactory 方法的实现原理、源代码分析以及实现过程:
实现原理
-
标准线程创建: 创建的线程工厂将生成具有默认属性的线程。
-
线程名称: 生成的线程具有默认的线程名称前缀,通常是 "pool-x-thread-y",其中 x 和 y 是数字。
-
线程优先级: 线程的优先级设置为 Thread.NORM_PRIORITY,这是 Java 线程的默认优先级。
-
非守护线程: 创建的线程不是守护线程(daemon threads),它们的存在不会阻止 JVM 退出。
源代码分析
Java 的 defaultThreadFactory 方法的具体实现细节并未完全公开,因为它是 Executors 类的一个私有静态方法。但是,我们可以根据 Java 的 ThreadFactory 接口和一些公开的源代码片段来分析其大致实现。
以下是 defaultThreadFactory 方法的调用示例:
public static ThreadFactory defaultThreadFactory() {
return new DefaultThreadFactory();
}
这里,DefaultThreadFactory 是 Executors 类的一个私有静态内部类,它实现了 ThreadFactory 接口。ThreadFactory 接口定义了一个 newThread(Runnable r) 方法,用于创建新的线程。
实现过程
-
初始化: 当调用 defaultThreadFactory 方法时,会返回一个新的 DefaultThreadFactory 实例。
-
线程创建: 使用这个工厂创建线程时,它会调用 newThread(Runnable r) 方法。
-
设置线程名称: 在 newThread(Runnable r) 方法的实现中,会创建一个新的 Thread 对象,并设置一个默认的线程名称。
-
设置线程组: 新线程会被分配到一个默认的线程组中。
-
线程优先级和守护状态: 线程的优先级设置为默认值,且线程不是守护线程。
示例代码
虽然我们不能查看 defaultThreadFactory 的具体实现,但是我们可以提供一个示例实现,以展示如何创建具有默认属性的线程:
public class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}
在这个示例中,DefaultThreadFactory 使用 AtomicInteger 来确保线程池和线程编号的唯一性。创建的线程名称具有前缀 "pool-x-thread-y",其中 x 和 y 是自增的数字。线程不是守护线程,且优先级设置为 Thread.NORM_PRIORITY。
特点
-
使用 defaultThreadFactory 创建的线程工厂生成的线程具有标准的 Java 线程属性。
-
这种线程工厂通常用于不需要特殊权限的应用程序。
-
由于线程不是守护线程,它们的存在可以维持 JVM 的运行,直到所有非守护线程执行完毕。
使用 defaultThreadFactory 可以确保线程在执行任务时具有标准的安全和执行属性,适合大多数常规用途。然而,如果应用程序需要特殊的线程属性,如守护线程或不同的优先级,可能需要自定义线程工厂。
使用场景:
适用于大多数标准应用程序,需要创建具有默认属性的线程。这是大多数 ExecutorService 实现的默认选择。
9. unconfigurableExecutorService(ExecutorService executor)
unconfigurableExecutorService 是 Java 中 java.util.concurrent 包的 Executors 类的一个静态工厂方法。这个方法用于创建一个不可配置的 ExecutorService 包装器,这意味着一旦包装后的 ExecutorService 被创建,就不能更改其配置,比如不能修改其线程池大小或任务队列等。
以下是 unconfigurableExecutorService 方法的实现原理、源代码分析以及实现过程:
实现原理
-
封装: 将现有的 ExecutorService 封装在一个不可配置的代理中。
-
不可修改: 所有修改配置的方法调用,如 shutdown, shutdownNow, setCorePoolSize 等,都将抛出 UnsupportedOperationException。
-
转发: 除了配置修改的方法外,其他方法调用将被转发到原始的 ExecutorService。
源代码分析
unconfigurableExecutorService 方法的具体实现细节并未完全公开,因为它是 Executors 类的一个私有静态方法。但是,我们可以根据 Java 的 ExecutorService 接口和代理机制来分析其大致实现。
以下是 unconfigurableExecutorService 方法的调用示例:
public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {
return new FinalizableDelegatedExecutorService(executor);
}
这里,FinalizableDelegatedExecutorService 是 Executors 类的一个私有静态内部类,它实现了 ExecutorService 接口,并代理了对另一个 ExecutorService 的调用。
实现过程
-
初始化: 当调用 unconfigurableExecutorService 方法时,会返回一个新的 FinalizableDelegatedExecutorService 实例,它将原始的 ExecutorService 作为参数。
-
方法调用拦截: 对 FinalizableDelegatedExecutorService 的方法调用将首先被拦截。
-
配置修改拦截: 如果调用的方法是用于修改配置的,比如 shutdown 或 shutdownNow,将抛出 UnsupportedOperationException。
-
转发其他调用: 对于其他不涉及配置修改的方法调用,比如 submit, execute, 将被转发到原始的 ExecutorService。
示例代码
下面V哥来模拟一个示例实现,以展示如何创建一个不可配置的 ExecutorService 代理:
public class UnconfigurableExecutorService implements ExecutorService {
private final ExecutorService executor;
public UnconfigurableExecutorService(ExecutorService executor) {
this.executor = executor;
}
@Override
public void shutdown() {
throw new UnsupportedOperationException("Shutdown not allowed");
}
@Override
public List<Runnable> shutdownNow() {
throw new UnsupportedOperationException("Shutdown not allowed");
}
@Override
public boolean isShutdown() {
return executor.isShutdown();
}
@Override
public boolean isTerminated() {
return executor.isTerminated();
}
@Override
public void execute(Runnable command) {
executor.execute(command);
}
// 其他 ExecutorService 方法的实现,遵循相同的模式
}
在这个示例中,UnconfigurableExecutorService 拦截了 shutdown 和 shutdownNow 方法,并抛出了异常。其他方法则直接转发到原始的 ExecutorService。
特点
-
使用 unconfigurableExecutorService 创建的 ExecutorService 代理确保了线程池的配置不能被外部修改。
-
这可以用于防止意外地更改线程池的状态,提高线程池使用的安全性。
-
除了配置修改的方法外,其他所有方法都保持了原有 ExecutorService 的行为。
使用 unconfigurableExecutorService 可以为现有的 ExecutorService 提供一个安全层,确保它们的状态不会被意外地更改。这对于在多线程环境中共享 ExecutorService 时特别有用。
使用场景:
适用于需要确保线程池配置在创建后不被更改的场景。例如,当多个组件共享同一个线程池时,可以防止一个组件意外修改配置。
文章转载自:威哥爱编程