Hay un RFE abierto para esto con Oracle. Según los comentarios del empleado de Oracle, parece que no entienden el problema y no lo solucionarán. Es una de estas cosas que es muy fácil de admitir en el JDK (sin romper la compatibilidad con versiones anteriores), por lo que es una pena que el RFE se malinterprete.
Como se señaló, debe implementar su propia ThreadFactory . Si no desea obtener Guava o Apache Commons solo para este propósito, le proporciono aquí una ThreadFactory
implementación que puede usar. Es exactamente similar a lo que obtienes del JDK, excepto por la capacidad de establecer el prefijo del nombre del hilo en algo más que "pool".
package org.demo.concurrency;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* ThreadFactory with the ability to set the thread name prefix.
* This class is exactly similar to
* {@link java.util.concurrent.Executors#defaultThreadFactory()}
* from JDK8, except for the thread naming feature.
*
* <p>
* The factory creates threads that have names on the form
* <i>prefix-N-thread-M</i>, where <i>prefix</i>
* is a string provided in the constructor, <i>N</i> is the sequence number of
* this factory, and <i>M</i> is the sequence number of the thread created
* by this factory.
*/
public class ThreadFactoryWithNamePrefix implements ThreadFactory {
// Note: The source code for this class was based entirely on
// Executors.DefaultThreadFactory class from the JDK8 source.
// The only change made is the ability to configure the thread
// name prefix.
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
/**
* Creates a new ThreadFactory where threads are created with a name prefix
* of <code>prefix</code>.
*
* @param prefix Thread name prefix. Never use a value of "pool" as in that
* case you might as well have used
* {@link java.util.concurrent.Executors#defaultThreadFactory()}.
*/
public ThreadFactoryWithNamePrefix(String prefix) {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup()
: Thread.currentThread().getThreadGroup();
namePrefix = prefix + "-"
+ poolNumber.getAndIncrement()
+ "-thread-";
}
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon()) {
t.setDaemon(false);
}
if (t.getPriority() != Thread.NORM_PRIORITY) {
t.setPriority(Thread.NORM_PRIORITY);
}
return t;
}
}
Cuando quiera usarlo, simplemente aproveche el hecho de que todos los Executors
métodos le permiten proporcionar el suyo propio ThreadFactory
.
Esta
Executors.newSingleThreadExecutor();
dará un ExecutorService donde se nombran hilos pool-N-thread-M
pero usando
Executors.newSingleThreadExecutor(new ThreadFactoryWithNamePrefix("primecalc"));
obtendrá un ExecutorService donde se nombran los hilos primecalc-N-thread-M
. Voila!