org.aoju.bus.core.thread

Class ExecutorBuilder

java.lang.Object

org.aoju.bus.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异常
 

Since:

JDK 1.8+

Version:

6.3.5

Author:

Kimi Liu

See Also:

Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from interface org.aoju.bus.core.builder.Builder

Builder.HashKey

Field Summary

Fields

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

Constructor Summary

Constructors

Constructor and Description
ExecutorBuilder()

Method Summary

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

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

create

public static ExecutorBuilder create()

创建ExecutorBuilder，开始构建

Returns:

ExecutorBuilder

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时始终放入此队列，此时maximumPoolSize无效。
                        当构造LinkedBlockingQueue对象时传入参数，变为有界队列，队列满时，运行线程小于maxPoolSize时会创建新线程，否则触发异常策略
 3. ArrayBlockingQueue  有界队列，相对无界队列有利于控制队列大小，队列满时，运行线程小于maxPoolSize时会创建新线程，否则触发异常策略
 

Parameters:

workQueue - 队列

Returns:

this

useArrayBlockingQueue

public ExecutorBuilder useArrayBlockingQueue(int capacity)

使用ArrayBlockingQueue 做为等待队列 有界队列，相对无界队列有利于控制队列大小，队列满时，运行线程小于maxPoolSize时会创建新线程，否则触发异常策略

Parameters:

capacity - 队列容量

Returns:

this

useSynchronousQueue

public ExecutorBuilder useSynchronousQueue()

使用SynchronousQueue 做为等待队列(非公平策略) 它将任务直接提交给线程而不保持它们。当运行线程小于maxPoolSize时会创建新线程，否则触发异常策略

Returns:

this

useSynchronousQueue

public ExecutorBuilder useSynchronousQueue(boolean fair)

使用SynchronousQueue 做为等待队列 它将任务直接提交给线程而不保持它们。当运行线程小于maxPoolSize时会创建新线程，否则触发异常策略

Parameters:

fair - 是否使用公平访问策略

Returns:

this

setThreadFactory

public ExecutorBuilder setThreadFactory(ThreadFactory threadFactory)

设置线程工厂，用于自定义线程创建

Parameters:

threadFactory - 线程工厂

Returns:

this

See Also:

ThreadBuilder

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

build

public ThreadPoolExecutor build()

构建ThreadPoolExecutor

Specified by:

build in interface Builder<ThreadPoolExecutor>

Returns:

被构建的对象

buildFinalizable

public ExecutorService buildFinalizable()

创建有回收关闭功能的ExecutorService

Returns:

创建有回收关闭功能的ExecutorService