找人做微信网站,做网站需要做手机版吗,网站建设进度及实施过程,外贸类网站建设在Java中#xff0c;Executors 类提供了多种静态工厂方法来创建不同类型的线程池。在学习线程池的过程中#xff0c;一定避不开Executors类#xff0c;掌握这个类的使用、原理、使用场景#xff0c;对于实际项目开发时#xff0c;运用自如#xff0c;以下是一些常用的方法…在Java中Executors 类提供了多种静态工厂方法来创建不同类型的线程池。在学习线程池的过程中一定避不开Executors类掌握这个类的使用、原理、使用场景对于实际项目开发时运用自如以下是一些常用的方法V哥来一一细说 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 SynchronousQueueRunnable());
}参数解释
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 LinkedBlockingQueueRunnable() // 使用阻塞队列来存储任务);
}参数解释
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 LinkedBlockingQueueRunnable() // 使用阻塞队列来存储任务);
}参数解释
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 {Overridepublic Thread newThread(Runnable r) {return AccessController.doPrivileged(new PrivilegedAction() {Overridepublic Thread run() {return new Thread(r);}});}
}在这个示例中PrivilegedAction 是一个实现了 PrivilegedActionT 接口的匿名类其 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;}Overridepublic void shutdown() {throw new UnsupportedOperationException(Shutdown not allowed);}Overridepublic ListRunnable shutdownNow() {throw new UnsupportedOperationException(Shutdown not allowed);}Overridepublic boolean isShutdown() {return executor.isShutdown();}Overridepublic boolean isTerminated() {return executor.isTerminated();}Overridepublic void execute(Runnable command) {executor.execute(command);}// 其他 ExecutorService 方法的实现遵循相同的模式
}在这个示例中UnconfigurableExecutorService 拦截了 shutdown 和 shutdownNow 方法并抛出了异常。其他方法则直接转发到原始的 ExecutorService。
特点
使用 unconfigurableExecutorService 创建的 ExecutorService 代理确保了线程池的配置不能被外部修改。这可以用于防止意外地更改线程池的状态提高线程池使用的安全性。除了配置修改的方法外其他所有方法都保持了原有 ExecutorService 的行为。
使用 unconfigurableExecutorService 可以为现有的 ExecutorService 提供一个安全层确保它们的状态不会被意外地更改。这对于在多线程环境中共享 ExecutorService 时特别有用。
使用场景
适用于需要确保线程池配置在创建后不被更改的场景。例如当多个组件共享同一个线程池时可以防止一个组件意外修改配置。
最后
以上是V哥在授课过程中整理的关于Executors 9种创建线程池的方法及原理分析分享给大家希望对正在学习 Java 的你有所帮助每天分享技术干货欢迎关注威哥爱编程你的鼓励是V哥技术创作路上的助推器不喜勿喷感谢。
