/**
* Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.util;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* An implementation of {@link ThreadFactory} which allows the naming of threads rather than simple use of a numeric thread factory ID.
*/
public class NamedThreadPoolFactory implements ThreadFactory {
/**
* The thread pool name.
*/
private final String _poolName;
/**
* The thread group.
*/
private final ThreadGroup _group;
/**
* The name prefix to use.
*/
private final String _namePrefix;
/**
* The next thread number to assign.
*/
private final AtomicInteger _nextThreadNumber = new AtomicInteger();
/**
* Whether to make the thread a daemon.
*/
private final boolean _makeDaemon;
/**
* Creates an MDC aware, named, cached thread pool.
*
* @param poolName the name to be given to the threads used by the pool
* @param makeDaemon specifies whether to use daemon threads
* @return a new executor service
*/
public static ExecutorService newCachedThreadPool(String poolName, boolean makeDaemon) {
return new MdcAwareThreadPoolExecutor(new NamedThreadPoolFactory(poolName, makeDaemon));
}
/**
* Creates an MDC aware, named, cached thread pool using daemon threads.
*
* @param poolName the name to be given to the threads used by the pool
* @return a new executor service
*/
public static ExecutorService newCachedThreadPool(String poolName) {
return newCachedThreadPool(poolName, true);
}
/**
* Creates a factory with a pool name.
*
* @param poolName the pool name, not null
*/
public NamedThreadPoolFactory(String poolName) {
this(poolName, true);
}
/**
* Creates a factory with a pool name and daemon flag.
*
* @param poolName the pool name, not null
* @param makeDaemon whether to make the thread a daemon
*/
public NamedThreadPoolFactory(String poolName, boolean makeDaemon) {
ArgumentChecker.notNull(poolName, "poolName");
_poolName = poolName;
_makeDaemon = makeDaemon;
SecurityManager s = System.getSecurityManager();
_group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
_namePrefix = _poolName + "-";
}
/**
* Gets the pool name.
*
* @return the poolName the pool name, not null
*/
public String getPoolName() {
return _poolName;
}
/**
* Gets whether the factory creates daemon threads.
*
* @return whether the factory creates daemon threads
*/
public boolean isDaemon() {
return _makeDaemon;
}
protected Thread createThread(final ThreadGroup group, final Runnable runnable, final String threadName, final int stackSize) {
return new Thread(group, runnable, threadName, stackSize);
}
/**
* Creates a new thread using the stored details. This creates a thread using the pool name as a prefix.
*
* @param runnable the runnable to use, not null
* @return the created thread, not null
*/
@Override
public Thread newThread(Runnable runnable) {
String threadName = _namePrefix + _nextThreadNumber.incrementAndGet();
Thread t = createThread(_group, runnable, threadName, 0);
if (t.isDaemon() != _makeDaemon) {
t.setDaemon(_makeDaemon);
}
return t;
}
}