{
/**
* 构建
*
- * @param builder {@link ThreadFactoryBuilder}
+ * @param builder {@code ThreadFactoryBuilder}
* @return {@link ThreadFactory}
*/
private static ThreadFactory build(ThreadFactoryBuilder builder) {
diff --git a/hutool-core/src/main/java/cn/hutool/core/thread/ThreadUtil.java b/hutool-core/src/main/java/cn/hutool/core/thread/ThreadUtil.java
index 28c526135..b6f6d242b 100644
--- a/hutool-core/src/main/java/cn/hutool/core/thread/ThreadUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/thread/ThreadUtil.java
@@ -1,7 +1,5 @@
package cn.hutool.core.thread;
-import cn.hutool.core.thread.rejected.RejectedExecutionHandlerUtility;
-
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
@@ -43,114 +41,6 @@ public class ThreadUtil {
return builder.build();
}
- /**
- * 获取一个新的线程池，默认的策略如下
- *
- * 1. 核心线程数与最大线程数为nThreads指定的大小
- * 2. 默认使用LinkedBlockingQueue，默认队列大小为1024
- *
- *
- * @param nThreads 线程池大小
- * @param threadNamePrefix 线程名称前缀
- * @return ExecutorService
- */
- public static ExecutorService newFixedExecutor(int nThreads, String threadNamePrefix) {
- ThreadFactory threadFactory = ThreadFactoryBuilder.create().setNamePrefix(threadNamePrefix).build();
- ExecutorBuilder builder = ExecutorBuilder.create().setThreadFactory(threadFactory);
- if (nThreads > 0) {
- builder.setCorePoolSize(nThreads)
- .setMaxPoolSize(nThreads);
- }
- return builder.build();
- }
-
- /**
- * 获取一个新的线程池，默认的策略如下
- *
- * 1. 核心线程数与最大线程数为nThreads指定的大小
- * 2. 默认使用LinkedBlockingQueue，默认队列大小为1024
- * 3. 当执行拒绝策略的时候会处于阻塞状态，直到能添加到队列中或者被{@link Thread#interrupt()}中断
- *
- *
- * @param nThreads 线程池大小
- * @param threadNamePrefix 线程名称前缀
- * @return ExecutorService
- */
- public static ExecutorService newFixedBlockedExecutor(int nThreads, String threadNamePrefix) {
- ThreadFactory threadFactory = ThreadFactoryBuilder.create().setNamePrefix(threadNamePrefix).build();
- ExecutorBuilder builder = ExecutorBuilder.create()
- .setCorePoolSize(nThreads)
- .setMaxPoolSize(nThreads)
- .setThreadFactory(threadFactory)
- .setHandler(new RejectedExecutionHandlerUtility.BlockPolicy());
- return builder.build();
- }
-
- /**
- * 获取一个新的线程池，默认的策略如下
- *
- * 1. 核心线程数与最大线程数为nThreads指定的大小
- * 2. 默认使用LinkedBlockingQueue
- *
- *
- * @param nThreads 线程池大小
- * @param maximumQueueSize 队列大小
- * @param threadNamePrefix 线程名称前缀
- * @return ExecutorService
- */
- public static ExecutorService newFixedExecutor(int nThreads, int maximumQueueSize, String threadNamePrefix) {
- return newFixedExecutor(nThreads, maximumQueueSize, threadNamePrefix, null);
- }
-
- /**
- * 获取一个新的线程池，默认的策略如下
- *
- * 1. 核心线程数与最大线程数为nThreads指定的大小
- * 2. 默认使用LinkedBlockingQueue
- * 3. 当执行拒绝策略的时候会处于阻塞状态，直到能添加到队列中或者被{@link Thread#interrupt()}中断
- *
- *
- * @param nThreads 线程池大小
- * @param threadNamePrefix 线程名称前缀
- * @return ExecutorService
- */
- public static ExecutorService newFixedBlockingExecutor(int nThreads, int maximumQueueSize, String threadNamePrefix) {
- return newFixedExecutor(nThreads,
- maximumQueueSize,
- threadNamePrefix,
- new RejectedExecutionHandlerUtility.BlockPolicy());
- }
-
- /**
- * 获得一个新的线程池，默认策略如下
- *
- * 1. 核心线程数与最大线程数为nThreads指定的大小
- * 2. 默认使用LinkedBlockingQueue
- *
- *
- * @param nThreads 线程池大小
- * @param maximumQueueSize 队列大小
- * @param threadNamePrefix 线程名称前缀
- * @param handler 拒绝策略
- * @return ExecutorService
- */
- public static ExecutorService newFixedExecutor(int nThreads,
- int maximumQueueSize,
- String threadNamePrefix,
- RejectedExecutionHandler handler) {
-
- ThreadFactory threadFactory = ThreadFactoryBuilder.create().setNamePrefix(threadNamePrefix).build();
-
- ExecutorBuilder builder = ExecutorBuilder.create()
- .setCorePoolSize(nThreads)
- .setMaxPoolSize(nThreads)
- .setWorkQueue(new LinkedBlockingQueue<>(maximumQueueSize))
- .setThreadFactory(threadFactory)
- .setHandler(handler);
-
- return builder.build();
- }
-
/**
* 获得一个新的线程池，默认的策略如下：
*
@@ -240,6 +130,71 @@ public class ThreadUtil {
return ExecutorBuilder.create().setCorePoolSize(poolSize).setMaxPoolSize(poolSize).setKeepAliveTime(0L).build();
}
+ /**
+ * 获取一个新的线程池，默认的策略如下
+ *
+ * 1. 核心线程数与最大线程数为nThreads指定的大小
+ * 2. 默认使用LinkedBlockingQueue，默认队列大小为1024
+ * 3. 如果isBlocked为{code true}，当执行拒绝策略的时候会处于阻塞状态，直到能添加到队列中或者被{@link Thread#interrupt()}中断
+ *
+ *
+ * @param nThreads 线程池大小
+ * @param threadNamePrefix 线程名称前缀
+ * @param isBlocked 是否使用{@link BlockPolicy}策略
+ * @return ExecutorService
+ * @author luozongle
+ * @since 5.8.0
+ */
+ public static ExecutorService newFixedExecutor(int nThreads, String threadNamePrefix, boolean isBlocked) {
+ return newFixedExecutor(nThreads, 1024, threadNamePrefix, isBlocked);
+ }
+
+ /**
+ * 获取一个新的线程池，默认的策略如下
+ *
+ * 1. 核心线程数与最大线程数为nThreads指定的大小
+ * 2. 默认使用LinkedBlockingQueue
+ * 3. 当执行拒绝策略的时候会处于阻塞状态，直到能添加到队列中或者被{@link Thread#interrupt()}中断
+ *
+ *
+ * @param nThreads 线程池大小
+ * @param threadNamePrefix 线程名称前缀
+ * @return ExecutorService
+ * @author luozongle
+ * @since 5.8.0
+ */
+ public static ExecutorService newFixedExecutor(int nThreads, int maximumQueueSize, String threadNamePrefix, boolean isBlocked) {
+ return newFixedExecutor(nThreads, maximumQueueSize, threadNamePrefix,
+ (isBlocked ? RejectPolicy.BLOCK : RejectPolicy.ABORT).getValue());
+ }
+
+ /**
+ * 获得一个新的线程池，默认策略如下
+ *
+ * 1. 核心线程数与最大线程数为nThreads指定的大小
+ * 2. 默认使用LinkedBlockingQueue
+ *
+ *
+ * @param nThreads 线程池大小
+ * @param maximumQueueSize 队列大小
+ * @param threadNamePrefix 线程名称前缀
+ * @param handler 拒绝策略
+ * @return ExecutorService
+ * @author luozongle
+ * @since 5.8.0
+ */
+ public static ExecutorService newFixedExecutor(int nThreads,
+ int maximumQueueSize,
+ String threadNamePrefix,
+ RejectedExecutionHandler handler) {
+ return ExecutorBuilder.create()
+ .setCorePoolSize(nThreads).setMaxPoolSize(nThreads)
+ .setWorkQueue(new LinkedBlockingQueue<>(maximumQueueSize))
+ .setThreadFactory(createThreadFactory(threadNamePrefix))
+ .setHandler(handler)
+ .build();
+ }
+
/**
* 直接在公共线程池中执行线程
*
@@ -501,6 +456,18 @@ public class ThreadUtil {
return ThreadFactoryBuilder.create();
}
+ /**
+ * 创建自定义线程名称前缀的{@link ThreadFactory}
+ *
+ * @param threadNamePrefix 线程名称前缀
+ * @return {@link ThreadFactory}
+ * @see ThreadFactoryBuilder#build()
+ * @since 5.8.0
+ */
+ public static ThreadFactory createThreadFactory(String threadNamePrefix) {
+ return ThreadFactoryBuilder.create().setNamePrefix(threadNamePrefix).build();
+ }
+
/**
* 结束线程，调用此方法后，线程将抛出 {@link InterruptedException}异常
*
diff --git a/hutool-core/src/main/java/cn/hutool/core/thread/rejected/RejectedExecutionHandlerUtility.java b/hutool-core/src/main/java/cn/hutool/core/thread/rejected/RejectedExecutionHandlerUtility.java
deleted file mode 100644
index d85a6f907..000000000
--- a/hutool-core/src/main/java/cn/hutool/core/thread/rejected/RejectedExecutionHandlerUtility.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package cn.hutool.core.thread.rejected;
-
-import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.RejectedExecutionHandler;
-import java.util.concurrent.ThreadPoolExecutor;
-
-/**
- * 线程池拒绝策略工具类
- *
- * @author luozongle
- */
-public class RejectedExecutionHandlerUtility {
-
- /**
- * 当任务队列过长时处于阻塞状态，直到添加到队列中
- * 如果阻塞过程中被中断，就会抛出{@link InterruptedException}异常
- */
- public static class BlockPolicy implements RejectedExecutionHandler {
-
- public BlockPolicy() {
- }
-
- @Override
- public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
- try {
- e.getQueue().put(r);
- } catch (InterruptedException ex) {
- throw new RejectedExecutionException("Task " + r + " rejected from " + e);
- }
- }
- }
-}