ExecutorBuilder (hutool 6.0.0-M20 API)

java.lang.Object
- org.dromara.hutool.core.thread.ExecutorBuilder

All Implemented Interfaces:: Serializable, Builder<ThreadPoolExecutor>

public class ExecutorBuilder
extends Object
implements Builder<ThreadPoolExecutor>

ThreadPoolExecutor 建造者

     1. 如果池中任务数 < corePoolSize     -》 放入立即执行
     2. 如果池中任务数 > corePoolSize     -》 放入队列等待
     3. 队列满                              -》 新建线程立即执行
     4. 执行中的线程 > maxPoolSize        -》 触发handler（RejectedExecutionHandler）异常

Since:: 4.1.9
Author:: looly
See Also:: Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static int DEFAULT_QUEUE_CAPACITY
默认的等待队列容量

Fields
Modifier and Type	Field and Description
`static int`	`DEFAULT_QUEUE_CAPACITY` 默认的等待队列容量

Constructor Summary

Constructors
Constructor and Description

ExecutorBuilder()

Constructors
Constructor and Description
`ExecutorBuilder()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ThreadPoolExecutor`	`build()` 构建ThreadPoolExecutor
`ExecutorService`	`buildFinalizable()` 创建有回收关闭功能的ExecutorService
`static ExecutorBuilder`	`of()` 创建ExecutorBuilder，开始构建
`ExecutorBuilder`	`setAllowCoreThreadTimeOut(boolean allowCoreThreadTimeOut)` 设置线程执行超时后是否回收线程
`ExecutorBuilder`	`setCorePoolSize(int corePoolSize)` 设置初始池大小，默认0
`ExecutorBuilder`	`setHandler(RejectedExecutionHandler handler)` 设置当线程阻塞（block）时的异常处理器，所谓线程阻塞即线程池和等待队列已满，无法处理线程时采取的策略此处可以使用JDK预定义的几种策略，见`RejectPolicy`枚举
`ExecutorBuilder`	`setKeepAliveTime(long keepAliveTime)` 设置线程存活时间，即当池中线程多于初始大小时，多出的线程保留的时长，单位纳秒
`ExecutorBuilder`	`setKeepAliveTime(long keepAliveTime, TimeUnit unit)` 设置线程存活时间，即当池中线程多于初始大小时，多出的线程保留的时长
`ExecutorBuilder`	`setMaxPoolSize(int maxPoolSize)` 设置最大池大小（允许同时执行的最大线程数）
`ExecutorBuilder`	`setThreadFactory(ThreadFactory threadFactory)` 设置线程工厂，用于自定义线程创建
`ExecutorBuilder`	`setWorkQueue(BlockingQueue<Runnable> workQueue)` 设置队列，用于存在未执行的线程可选队列有： 1.
`ExecutorBuilder`	`useArrayBlockingQueue(int capacity)` 使用`ArrayBlockingQueue` 做为等待队列有界队列，相对无界队列有利于控制队列大小，队列满时，运行线程小于maxPoolSize时会创建新线程，否则触发异常策略
`ExecutorBuilder`	`useLinkedBlockingQueue(int capacity)` 使用`LinkedBlockingQueue` 作为等待队列队列满时，运行线程小于maxPoolSize时会创建新线程，否则触发异常策略
`ExecutorBuilder`	`useSynchronousQueue()` 使用`SynchronousQueue` 做为等待队列（非公平策略）它将任务直接提交给线程而不保持它们。
`ExecutorBuilder`	`useSynchronousQueue(boolean fair)` 使用`SynchronousQueue` 做为等待队列它将任务直接提交给线程而不保持它们。

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_QUEUE_CAPACITY
```
public static final int DEFAULT_QUEUE_CAPACITY
```
    默认的等待队列容量
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - ExecutorBuilder
```
public ExecutorBuilder()
```
- Method Detail
  - setCorePoolSize
```
public ExecutorBuilder setCorePoolSize(int corePoolSize)
```
    设置初始池大小，默认0
    
    Parameters:
    
    corePoolSize - 初始池大小
    
    Returns:
    
    this
  - setMaxPoolSize
```
public ExecutorBuilder setMaxPoolSize(int maxPoolSize)
```
    设置最大池大小（允许同时执行的最大线程数）
    
    Parameters:
    
    maxPoolSize - 最大池大小（允许同时执行的最大线程数）
    
    Returns:
    
    this
  - setKeepAliveTime
```
public ExecutorBuilder setKeepAliveTime(long keepAliveTime,
                                        TimeUnit unit)
```
    设置线程存活时间，即当池中线程多于初始大小时，多出的线程保留的时长
    
    Parameters:
    
    keepAliveTime - 线程存活时间
    
    unit - 单位
    
    Returns:
    
    this
  - setKeepAliveTime
```
public ExecutorBuilder setKeepAliveTime(long keepAliveTime)
```
    设置线程存活时间，即当池中线程多于初始大小时，多出的线程保留的时长，单位纳秒
    
    Parameters:
    
    keepAliveTime - 线程存活时间，单位纳秒
    
    Returns:
    
    this
  - setWorkQueue
```
public ExecutorBuilder setWorkQueue(BlockingQueue<Runnable> workQueue)
```
    设置队列，用于存在未执行的线程
    可选队列有：
```
 1. SynchronousQueue    它将任务直接提交给线程而不保持它们。当运行线程小于maxPoolSize时会创建新线程，否则触发异常策略
 2. LinkedBlockingQueue 默认无界队列，当运行线程大于corePoolSize时始终放入此队列，此时maxPoolSize无效。
                        当构造LinkedBlockingQueue对象时传入参数，变为有界队列，队列满时，运行线程小于maxPoolSize时会创建新线程，否则触发异常策略
 3. ArrayBlockingQueue  有界队列，相对无界队列有利于控制队列大小，队列满时，运行线程小于maxPoolSize时会创建新线程，否则触发异常策略
 
```
    Parameters:
    
    workQueue - 队列
    
    Returns:
    
    this
  - useLinkedBlockingQueue
```
public ExecutorBuilder useLinkedBlockingQueue(int capacity)
```
    使用LinkedBlockingQueue 作为等待队列
    队列满时，运行线程小于maxPoolSize时会创建新线程，否则触发异常策略
    
    Parameters:
    
    capacity - 队列容量
    
    Returns:
    
    this
    
    Since:
    
    6.0.0
  - useArrayBlockingQueue
```
public ExecutorBuilder useArrayBlockingQueue(int capacity)
```
    使用ArrayBlockingQueue 做为等待队列
    有界队列，相对无界队列有利于控制队列大小，队列满时，运行线程小于maxPoolSize时会创建新线程，否则触发异常策略
    
    Parameters:
    
    capacity - 队列容量
    
    Returns:
    
    this
    
    Since:
    
    5.1.4
  - useSynchronousQueue
```
public ExecutorBuilder useSynchronousQueue()
```
    使用SynchronousQueue 做为等待队列（非公平策略）
    它将任务直接提交给线程而不保持它们。当运行线程小于maxPoolSize时会创建新线程，否则触发异常策略
    
    Returns:
    
    this
    
    Since:
    
    4.1.11
  - useSynchronousQueue
```
public ExecutorBuilder useSynchronousQueue(boolean fair)
```
    使用SynchronousQueue 做为等待队列
    它将任务直接提交给线程而不保持它们。当运行线程小于maxPoolSize时会创建新线程，否则触发异常策略
    
    Parameters:
    
    fair - 是否使用公平访问策略
    
    Returns:
    
    this
    
    Since:
    
    4.5.0
  - setThreadFactory
```
public ExecutorBuilder setThreadFactory(ThreadFactory threadFactory)
```
    设置线程工厂，用于自定义线程创建
    
    Parameters:
    
    threadFactory - 线程工厂
    
    Returns:
    
    this
    
    See Also:
    
    ThreadFactoryBuilder
  - setHandler
```
public ExecutorBuilder setHandler(RejectedExecutionHandler handler)
```
    设置当线程阻塞（block）时的异常处理器，所谓线程阻塞即线程池和等待队列已满，无法处理线程时采取的策略
    此处可以使用JDK预定义的几种策略，见RejectPolicy枚举
    
    Parameters:
    
    handler - RejectedExecutionHandler
    
    Returns:
    
    this
    
    See Also:
    
    RejectPolicy
  - setAllowCoreThreadTimeOut
```
public ExecutorBuilder setAllowCoreThreadTimeOut(boolean allowCoreThreadTimeOut)
```
    设置线程执行超时后是否回收线程
    
    Parameters:
    
    allowCoreThreadTimeOut - 线程执行超时后是否回收线程
    
    Returns:
    
    this
  - of
```
public static ExecutorBuilder of()
```
    创建ExecutorBuilder，开始构建
    
    Returns:
    
    this
  - build
```
public ThreadPoolExecutor build()
```
    构建ThreadPoolExecutor
    
    Specified by:
    
    build in interface Builder<ThreadPoolExecutor>
    
    Returns:
    
    被构建的对象
  - buildFinalizable
```
public ExecutorService buildFinalizable()
```
    创建有回收关闭功能的ExecutorService
    
    Returns:
    
    创建有回收关闭功能的ExecutorService
    
    Since:
    
    5.1.4

Class ExecutorBuilder

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_QUEUE_CAPACITY

Constructor Detail

ExecutorBuilder

Method Detail

setCorePoolSize

setMaxPoolSize

setKeepAliveTime

setKeepAliveTime

setWorkQueue

useLinkedBlockingQueue

useArrayBlockingQueue

useSynchronousQueue

useSynchronousQueue

setThreadFactory

setHandler

setAllowCoreThreadTimeOut

of

build

buildFinalizable