org.apache.sling.commons.threads.ModifiableThreadPoolConfig Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
package org.apache.sling.commons.threads;
import org.osgi.annotation.versioning.ProviderType;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
/**
* This is a modifiable thread pool configuration that can be instantiated
* and then configured to create a new thread pool.
*
* The default values for this configuration are:
* - min pool size: 5
* - max pool size: 5
* - queue size: -1
* - keep alive time: 60000
* - block policy: RUN
* - shutdown graceful: true
* - shutdown wait time: -1
* - priority: NORM
* - daemon: false
* - factory: null (= default jvm thread factory)
*/
@ProviderType
public final class ModifiableThreadPoolConfig implements ThreadPoolConfig {
/** Configuration property for the min pool size. */
public static final String PROPERTY_MIN_POOL_SIZE = "minPoolSize";
/** Configuration property for the max pool size. */
public static final String PROPERTY_MAX_POOL_SIZE = "maxPoolSize";
/** Configuration property for the queue size. */
public static final String PROPERTY_QUEUE_SIZE = "queueSize";
/** Configuration property for the max thread age. */
public static final String PROPERTY_MAX_THREAD_AGE = "maxThreadAge";
/** Configuration property for the keep alive time. */
public static final String PROPERTY_KEEP_ALIVE_TIME = "keepAliveTime";
/** Configuration property for the block policy. */
public static final String PROPERTY_BLOCK_POLICY = "blockPolicy";
/** Configuration property for the shutdown graceful flag. */
public static final String PROPERTY_SHUTDOWN_GRACEFUL = "shutdownGraceful";
/** Configuration property for the shutdown wait time. */
public static final String PROPERTY_SHUTDOWN_WAIT_TIME = "shutdownWaitTime";
/** Configuration property for the priority. */
public static final String PROPERTY_PRIORITY = "priority";
/** Configuration property for the daemon flag. */
public static final String PROPERTY_DAEMON = "daemon";
/** Configuration property for the thread pool name. */
public static final String PROPERTY_NAME = "name";
/** The min pool size. */
private int minPoolSize = 5;
/** The max pool size. */
private int maxPoolSize = 5;
/** The queue size */
private int queueSize = -1;
/** Max age of a thread in milliseconds
* @deprecated Since version 3.4.0 always returns -1 as threads are no longer retired
* but instead the thread locals are cleaned up (SLING-6261)
*/
@Deprecated
private long maxThreadAge = -1;
/** The keep alive time. */
private long keepAliveTime = 60000L;
/** The thread pool policy. Default is RUN. */
private ThreadPoolPolicy blockPolicy = ThreadPoolPolicy.RUN;
/** Try to shutdown gracefully? */
private boolean shutdownGraceful = true;
/** Wait time during shutdown. */
private int shutdownWaitTimeMs = -1;
/** Optional thread factory. */
private ThreadFactory factory;
/** Thread priority. */
private ThreadPriority priority = ThreadPriority.NORM;
/** Create daemon threads? */
private boolean isDaemon = false;
/**
* Create a new default configuration.
*/
public ModifiableThreadPoolConfig() {
// nothing to do
}
/**
* Clone an existing configuration
* @param copy The config to clone
*/
public ModifiableThreadPoolConfig(final ThreadPoolConfig copy) {
if ( copy != null ) {
this.minPoolSize = copy.getMinPoolSize();
this.maxPoolSize = copy.getMaxPoolSize();
this.queueSize = copy.getQueueSize();
this.maxThreadAge = copy.getMaxThreadAge();
this.keepAliveTime = copy.getKeepAliveTime();
this.blockPolicy = copy.getBlockPolicy();
this.shutdownGraceful = copy.isShutdownGraceful();
this.shutdownWaitTimeMs = copy.getShutdownWaitTimeMs();
this.factory = copy.getFactory();
this.priority = copy.getPriority();
this.isDaemon = copy.isDaemon();
}
}
/**
* @see org.apache.sling.commons.threads.ThreadPoolConfig#getMinPoolSize()
*/
public int getMinPoolSize() {
return minPoolSize;
}
/**
* Set the min pool size.
* @param minPoolSize New min pool size.
*/
public void setMinPoolSize(final int minPoolSize) {
this.minPoolSize = minPoolSize;
}
/**
* @see org.apache.sling.commons.threads.ThreadPoolConfig#getMaxPoolSize()
*/
public int getMaxPoolSize() {
return maxPoolSize;
}
/**
* Set the max pool size.
* @param maxPoolSize New max pool size.
*/
public void setMaxPoolSize(final int maxPoolSize) {
this.maxPoolSize = maxPoolSize;
}
/**
* @see org.apache.sling.commons.threads.ThreadPoolConfig#getQueueSize()
*/
public int getQueueSize() {
return queueSize;
}
/**
* Set the queue size.
* @param queueSize New queue size.
*/
public void setQueueSize(final int queueSize) {
this.queueSize = queueSize;
}
/*
* (non-Javadoc)
* @see org.apache.sling.commons.threads.ThreadPoolConfig#getMaxThreadAge()
*/
@Override
public long getMaxThreadAge() {
return maxThreadAge;
}
/**
* Set the max thread age.
* @param maxThreadAge New max thread age in milliseconds.
* @deprecated Since version 3.4.0 should no longer be called, as threads are no longer retired
* but instead the thread locals are cleaned up (SLING-6261)
*/
public void setMaxThreadAge(final long maxThreadAge) {
this.maxThreadAge = maxThreadAge;
}
/**
* @see org.apache.sling.commons.threads.ThreadPoolConfig#getKeepAliveTime()
*/
public long getKeepAliveTime() {
return keepAliveTime;
}
/**
* Set the keep alive time.
* @param keepAliveTime New keep alive time.
*/
public void setKeepAliveTime(final long keepAliveTime) {
this.keepAliveTime = keepAliveTime;
}
/**
* @see org.apache.sling.commons.threads.ThreadPoolConfig#getBlockPolicy()
*/
public ThreadPoolPolicy getBlockPolicy() {
return blockPolicy;
}
/**
* Set the block policy.
* @param blockPolicy The new block policy.
* @throws IllegalArgumentException If blockPolicy is null.
*/
public void setBlockPolicy(final ThreadPoolPolicy blockPolicy) {
this.blockPolicy = blockPolicy;
if ( blockPolicy == null ) {
throw new IllegalArgumentException("Policy must not be null.");
}
}
/**
* @see org.apache.sling.commons.threads.ThreadPoolConfig#isShutdownGraceful()
*/
public boolean isShutdownGraceful() {
return shutdownGraceful;
}
/**
* Set if the pool should be shutdown graceful.
* @param shutdownGraceful The shutdown graceful setting.
*/
public void setShutdownGraceful(final boolean shutdownGraceful) {
this.shutdownGraceful = shutdownGraceful;
}
/**
* @see org.apache.sling.commons.threads.ThreadPoolConfig#getShutdownWaitTimeMs()
*/
public int getShutdownWaitTimeMs() {
return shutdownWaitTimeMs;
}
/**
* Set the shutdown wait time.
* @param shutdownWaitTimeMs The new shutdown wait time.
*/
public void setShutdownWaitTimeMs(final int shutdownWaitTimeMs) {
this.shutdownWaitTimeMs = shutdownWaitTimeMs;
}
/**
* @see org.apache.sling.commons.threads.ThreadPoolConfig#getFactory()
*/
public ThreadFactory getFactory() {
return factory;
}
/**
* Set the thread factory.
* @param factory The thread factory to be used or null to use
* the default thread factory.
*/
public void setFactory(final ThreadFactory factory) {
this.factory = factory;
}
/**
* @see org.apache.sling.commons.threads.ThreadPoolConfig#getPriority()
*/
public ThreadPriority getPriority() {
return priority;
}
/**
* Set the thread priority.
* @param priority The thread priority.
* @throws IllegalArgumentException If priority is null.
*/
public void setPriority(final ThreadPriority priority) {
if ( priority == null ) {
throw new IllegalArgumentException("Priority must not be null.");
}
this.priority = priority;
}
/**
* @see org.apache.sling.commons.threads.ThreadPoolConfig#isDaemon()
*/
public boolean isDaemon() {
return isDaemon;
}
/**
* Set the daemon handling.
* @param isDaemon The daemon setting.
*/
public void setDaemon(final boolean isDaemon) {
this.isDaemon = isDaemon;
}
@Override
public boolean equals(Object obj) {
if ( obj instanceof ModifiableThreadPoolConfig ) {
final ModifiableThreadPoolConfig o = (ModifiableThreadPoolConfig)obj;
return this.minPoolSize == o.minPoolSize
&& this.maxPoolSize == o.maxPoolSize
&& this.queueSize == o.queueSize
&& this.maxThreadAge == o.maxThreadAge
&& this.keepAliveTime == o.keepAliveTime
&& this.blockPolicy.equals(o.blockPolicy)
&& this.shutdownGraceful == o.shutdownGraceful
&& this.shutdownWaitTimeMs == o.shutdownWaitTimeMs
&& this.priority.equals(o.priority)
&& this.isDaemon == o.isDaemon;
}
return false;
}
@Override
public int hashCode() {
// we actually don't need hash code, but we don't want to violate the
// contract with equals
return this.blockPolicy.hashCode();
}
}