com.azaptree.services.executor.ThreadPoolConfig.java Source code

Java tutorial

Introduction

Here is the source code for com.azaptree.services.executor.ThreadPoolConfig.java

Source

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();
    }

}