package com.azaptree.services.executor;
/*
* #%L
* AZAPTREE-EXECUTOR-SERVICE
* %%
* Copyright (C) 2012 AZAPTREE.COM
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
import java.util.Objects;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import javax.annotation.PostConstruct;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.slf4j.LoggerFactory;
public class ThreadPoolConfig {
private String name;
private int corePoolSize = 3;
private int maximumPoolSize = 20;
private long keepAliveTime = 1;
private TimeUnit keepAliveTimeUnit = TimeUnit.MINUTES;
private BlockingQueue<Runnable> workQueue = new SynchronousQueue<>();
private RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();
private boolean daemon = false;
private boolean allowCoreThreadTimeOut = false;
/**
* DEFAULT CONFIG:
*
* <code>
* int corePoolSize = 3;
*
* int maximumPoolSize = 20;
*
* long keepAliveTime = 1;
* TimeUnit keepAliveTimeUnit = TimeUnit.MINUTES;
*
* BlockingQueue<Runnable> workQueue = new SynchronousQueue<>();
* RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();
*
* boolean daemon = false;
*
* boolean allowCoreThreadTimeOut = false;
* </code>
*
*/
public ThreadPoolConfig() {
}
public ThreadPoolConfig(final String name) {
setName(name);
}
public ThreadPoolConfig(final String name, final boolean daemon) {
this(name);
setDaemon(daemon);
}
public ThreadPoolConfig(final String name, final int corePoolSize, final int maximumPoolSize) {
this(name);
setCorePoolSize(corePoolSize);
setMaximumPoolSize(maximumPoolSize);
}
public ThreadPoolConfig(final String name, final int corePoolSize, final int maximumPoolSize, final boolean daemon) {
this(name, corePoolSize, maximumPoolSize);
setDaemon(daemon);
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final ThreadPoolConfig other = (ThreadPoolConfig) obj;
return Objects.equals(getName(), other.getName())
&& Objects.equals(getCorePoolSize(), other.getCorePoolSize())
&& Objects.equals(getMaximumPoolSize(), other.getMaximumPoolSize())
&& Objects.equals(getKeepAliveTime(), other.getKeepAliveTime())
&& Objects.equals(getKeepAliveTimeUnit(), other.getKeepAliveTimeUnit())
&& Objects.equals(isDaemon(), other.isDaemon())
&& Objects.equals(isAllowCoreThreadTimeOut(), other.isAllowCoreThreadTimeOut())
&& Objects.equals(getHandler() != null ? getHandler().getClass().getName() : null, other.getHandler() != null ? other.getHandler().getClass()
.getName() : null)
&& Objects.equals(getWorkQueue() != null ? getWorkQueue().getClass().getName() : null, other.getWorkQueue() != null ? other.getWorkQueue()
.getClass().getName() : null);
}
@Min(1)
public int getCorePoolSize() {
return corePoolSize;
}
public RejectedExecutionHandler getHandler() {
return handler;
}
@Min(1)
public long getKeepAliveTime() {
return keepAliveTime;
}
@NotNull
public TimeUnit getKeepAliveTimeUnit() {
return keepAliveTimeUnit;
}
@Min(1)
public int getMaximumPoolSize() {
return maximumPoolSize;
}
public String getName() {
return name;
}
@NotNull
public ThreadFactory getThreadFactory() {
if (StringUtils.isBlank(name) && !daemon) {
return Executors.defaultThreadFactory();
}
return new ThreadFactory() {
private final AtomicInteger threadCounter = new AtomicInteger(0);
@Override
public Thread newThread(final Runnable r) {
final Thread t = new Thread(r, String.format("%s-%d", name, threadCounter.incrementAndGet()));
t.setDaemon(daemon);
return t;
}
};
}
@NotNull
public BlockingQueue<Runnable> getWorkQueue() {
return workQueue;
}
@Override
public int hashCode() {
final String handlerClass = getHandler() != null ? getHandler().getClass().getName() : "null";
final String workQueueClass = getWorkQueue() != null ? getWorkQueue().getClass().getName() : "null";
return Objects.hash(name,
corePoolSize, maximumPoolSize,
keepAliveTime, keepAliveTimeUnit,
daemon, allowCoreThreadTimeOut,
handlerClass, workQueueClass);
}
@PostConstruct
public void init() {
LoggerFactory.getLogger(getClass()).info("{}", this);
}
public boolean isAllowCoreThreadTimeOut() {
return allowCoreThreadTimeOut;
}
public boolean isDaemon() {
return daemon;
}
public void setAllowCoreThreadTimeOut(final boolean allowCoreThreadTimeOut) {
this.allowCoreThreadTimeOut = allowCoreThreadTimeOut;
}
public void setCorePoolSize(final int corePoolSize) {
this.corePoolSize = corePoolSize;
}
public void setDaemon(final boolean daemon) {
this.daemon = daemon;
}
public void setHandler(final RejectedExecutionHandler handler) {
this.handler = handler;
}
public void setKeepAliveTime(final long keepAliveTime) {
this.keepAliveTime = keepAliveTime;
}
public void setKeepAliveTimeUnit(final TimeUnit unit) {
keepAliveTimeUnit = unit;
}
public void setMaximumPoolSize(final int maximumPoolSize) {
this.maximumPoolSize = maximumPoolSize;
}
public void setName(final String name) {
this.name = name;
}
public void setWorkQueue(final BlockingQueue<Runnable> workQueue) {
this.workQueue = workQueue;
}
@Override
public String toString() {
final ToStringBuilder sb = new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE);
sb.append("name", name);
sb.append("corePoolSize", corePoolSize);
sb.append("keepAliveTime", keepAliveTime);
sb.append("keepAliveTimeUnit", keepAliveTimeUnit);
sb.append("daemon", daemon);
sb.append("allowCoreThreadTimeOut", allowCoreThreadTimeOut);
if (workQueue != null) {
sb.append("workQueue", workQueue.getClass().getName());
}
if (handler != null) {
sb.append("handler", handler.getClass().getName());
}
return sb.toString();
}
}