Nombrar hilos y grupos de hilos de ExecutorService

Digamos que tengo una aplicación que utiliza el Executorframework como tal

Executors.newSingleThreadExecutor().submit(new Runnable(){
    @Override
    public void run(){
        // do stuff
    }
}

Cuando ejecuto esta aplicación en el depurador, un hilo se crea con el siguiente nombre (por defecto): Thread[pool-1-thread-1]. Como puede ver, esto no es terriblemente útil y, por lo que puedo decir, el Executormarco no proporciona una manera fácil de nombrar los hilos o grupos de hilos creados.

Entonces, ¿cómo se hace para proporcionar nombres para los hilos / grupos de hilos? Por ejemplo, Thread[FooPool-FooThread].

Podrías proporcionar un ThreadFactorya newSingleThreadScheduledExecutor(ThreadFactory threadFactory). La fábrica será responsable de crear hilos y podrá nombrarlos.

Para citar el Javadoc :

Crear nuevos hilos

Se crean nuevos hilos usando a ThreadFactory. Si no se especifica lo contrario, Executors.defaultThreadFactory()se utiliza un, que crea subprocesos para que todos estén en el mismo ThreadGroupy con la misma NORM_PRIORITYprioridad y estado de no demonio. Al proporcionar un diferente ThreadFactory, puede alterar el nombre del hilo, el grupo de hilos, la prioridad, el estado del demonio, etc. Si ThreadFactoryno se puede crear un hilo cuando se le pregunta al devolver nulo desde newThread, el ejecutor continuará, pero es posible que no pueda ejecutar ninguna tarea

La guayaba casi siempre tiene lo que necesitas .

ThreadFactory namedThreadFactory = 
  new ThreadFactoryBuilder().setNameFormat("my-sad-thread-%d").build()

y pasárselo a tu ExecutorService.

Puede intentar proporcionar su propia fábrica de hilos, que creará hilos con los nombres apropiados. Aquí hay un ejemplo:

class YourThreadFactory implements ThreadFactory {
   public Thread newThread(Runnable r) {
     return new Thread(r, "Your name");
   }
 }

Executors.newSingleThreadExecutor(new YourThreadFactory()).submit(someRunnable);

También puede cambiar el nombre de su hilo después, mientras se ejecuta el hilo:

Thread.currentThread().setName("FooName");

Eso podría ser interesante si, por ejemplo, está utilizando el mismo ThreadFactory para diferentes tipos de tareas.

El BasicThreadFactoryde Apache Commons-lang también es útil para proporcionar el comportamiento de nombres. En lugar de escribir una clase interna anónima, puede usar el generador para nombrar los hilos como desee. Aquí está el ejemplo de los javadocs:

 // Create a factory that produces daemon threads with a naming pattern and
 // a priority
 BasicThreadFactory factory = new BasicThreadFactory.Builder()
     .namingPattern("workerthread-%d")
     .daemon(true)
     .priority(Thread.MAX_PRIORITY)
     .build();
 // Create an executor service for single-threaded execution
 ExecutorService exec = Executors.newSingleThreadExecutor(factory);

Si está utilizando Spring, hay CustomizableThreadFactoryuna opción para establecer un prefijo de nombre de hilo.

Ejemplo:

ExecutorService alphaExecutor =
    Executors.newFixedThreadPool(10, new CustomizableThreadFactory("alpha-"));

Alternativamente, puede crear su ExecutorServicecomo un Spring bean usando ThreadPoolExecutorFactoryBean, luego los hilos se nombrarán con el beanName-prefijo.

@Bean
public ThreadPoolExecutorFactoryBean myExecutor() {
    ThreadPoolExecutorFactoryBean executorFactoryBean = new ThreadPoolExecutorFactoryBean();
    // configuration of your choice
    return executorFactoryBean;
}

En el ejemplo anterior, los hilos se nombrarán con myExecutor-prefijo. Puede establecer el prefijo explícitamente en un valor diferente (p. Ej. "myPool-") Configurando executorFactoryBean.setThreadNamePrefix("myPool-")el bean de fábrica.

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 ThreadFactoryimplementació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 Executorsmétodos le permiten proporcionar el suyo propio ThreadFactory.

Esta

    Executors.newSingleThreadExecutor();

dará un ExecutorService donde se nombran hilos pool-N-thread-Mpero usando

    Executors.newSingleThreadExecutor(new ThreadFactoryWithNamePrefix("primecalc"));

obtendrá un ExecutorService donde se nombran los hilos primecalc-N-thread-M. Voila!

private class TaskThreadFactory implements ThreadFactory
{

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r, "TASK_EXECUTION_THREAD");

        return t;
    }

}

Pase ThreadFactory a un servicio de ejecutor y estará listo para comenzar.

Una forma rápida y sucia es usar Thread.currentThread().setName(myName);el run()método.

Extender ThreadFactory

public interface ThreadFactory

Un objeto que crea nuevos hilos a pedido. El uso de fábricas de hilos elimina el cableado de las llamadas a nuevos hilos, permitiendo que las aplicaciones usen subclases de hilos especiales, prioridades, etc.

Thread newThread(Runnable r)

Construye un nuevo hilo. Las implementaciones también pueden inicializar prioridad, nombre, estado del demonio, ThreadGroup, etc.

Código de muestra:

import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

import java.util.concurrent.ThreadPoolExecutor.DiscardPolicy;

class SimpleThreadFactory implements ThreadFactory {
   String name;
   AtomicInteger threadNo = new AtomicInteger(0);

   public SimpleThreadFactory (String name){
       this.name = name;
   }
   public Thread newThread(Runnable r) {
     String threadName = name+":"+threadNo.incrementAndGet();
     System.out.println("threadName:"+threadName);
     return new Thread(r,threadName );
   }
   public static void main(String args[]){
        SimpleThreadFactory factory = new SimpleThreadFactory("Factory Thread");
        ThreadPoolExecutor executor= new ThreadPoolExecutor(1,1,60,
                    TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(1),new ThreadPoolExecutor.DiscardPolicy());


        final ExecutorService executorService = Executors.newFixedThreadPool(5,factory);

        for ( int i=0; i < 100; i++){
            executorService.submit(new Runnable(){
                 public void run(){
                    System.out.println("Thread Name in Runnable:"+Thread.currentThread().getName());
                 }
            });
        }
        executorService.shutdown();
    }
 }

salida:

java SimpleThreadFactory

thread no:1
thread no:2
Thread Name in Runnable:Factory Thread:1
Thread Name in Runnable:Factory Thread:2
thread no:3
thread no:4
Thread Name in Runnable:Factory Thread:3
Thread Name in Runnable:Factory Thread:4
thread no:5
Thread Name in Runnable:Factory Thread:5

.... etc.

Como ya se dijo en otras respuestas, puede crear y usar su propia implementación de la java.util.concurrent.ThreadFactoryinterfaz (no se requieren bibliotecas externas). Estoy pegando mi código a continuación porque es diferente a las respuestas anteriores, ya que usa el String.formatmétodo y toma un nombre base para los hilos como argumento de constructor:

import java.util.concurrent.ThreadFactory;

public class NameableThreadFactory implements ThreadFactory{
    private int threadsNum;
    private final String namePattern;

    public NameableThreadFactory(String baseName){
        namePattern = baseName + "-%d";
    }

    @Override
    public Thread newThread(Runnable runnable){
        threadsNum++;
        return new Thread(runnable, String.format(namePattern, threadsNum));
    }    
}

Y este es un ejemplo de uso:

ThreadFactory  threadFactory = new NameableThreadFactory("listenerThread");        
final ExecutorService executorService = Executors.newFixedThreadPool(5, threadFactory);

EDITAR : hacer que mi ThreadFactoryimplementación sea segura para subprocesos , gracias a @mchernyakov por señalarlo.
Aunque en ninguna parte de la ThreadFactorydocumentación se dice que sus implementaciones deben ser seguras para subprocesos, el hecho de que DefaultThreadFactoryes seguro para subprocesos es una gran pista:

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

public class NameableThreadFactory implements ThreadFactory{
    private final AtomicInteger threadsNum = new AtomicInteger();

    private final String namePattern;

    public NameableThreadFactory(String baseName){
        namePattern = baseName + "-%d";
    }

    @Override
    public Thread newThread(Runnable runnable){
        return new Thread(runnable, String.format(namePattern, threadsNum.addAndGet(1)));
    }    
}

La solución central de Java que utilizo para decorar fábricas existentes:

public class ThreadFactoryNameDecorator implements ThreadFactory {
    private final ThreadFactory defaultThreadFactory;
    private final String suffix;

    public ThreadFactoryNameDecorator(String suffix) {
        this(Executors.defaultThreadFactory(), suffix);
    }

    public ThreadFactoryNameDecorator(ThreadFactory threadFactory, String suffix) {
        this.defaultThreadFactory = threadFactory;
        this.suffix = suffix;
    }

    @Override
    public Thread newThread(Runnable task) {
        Thread thread = defaultThreadFactory.newThread(task);
        thread.setName(thread.getName() + "-" + suffix);
        return thread;
    }
}

En acción:

Executors.newSingleThreadExecutor(new ThreadFactoryNameDecorator("foo"));

Executors.newSingleThreadExecutor(r -> new Thread(r, "someName")).submit(getJob());

Runnable getJob() {
        return () -> {
            // your job
        };
}

Puede escribir su propia implementación de ThreadFactory, utilizando, por ejemplo, alguna implementación existente (como defaultThreadFactory) y cambiar el nombre al final.

Ejemplo de implementación de ThreadFactory:

class ThreadFactoryWithCustomName implements ThreadFactory {
    private final ThreadFactory threadFactory;
    private final String name;

    public ThreadFactoryWithCustomName(final ThreadFactory threadFactory, final String name) {
        this.threadFactory = threadFactory;
        this.name = name;
    }

    @Override
    public Thread newThread(final Runnable r) {
        final Thread thread = threadFactory.newThread(r);
        thread.setName(name);
        return thread;
    }
}

Y uso:

Executors.newSingleThreadExecutor(new ThreadFactoryWithCustomName(
        Executors.defaultThreadFactory(),
        "customName")
    );

Solía ​​hacer lo mismo que a continuación (requiere guavabiblioteca):

ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("SO-POOL-%d").build();
ExecutorService executorService = Executors.newFixedThreadPool(5,namedThreadFactory);

Me resulta más fácil usar una lambda como fábrica de hilos si solo desea cambiar el nombre de un solo ejecutor de hilos.

Executors.newSingleThreadExecutor(runnable -> new Thread(runnable, "Your name"));

Esta es mi fábrica personalizada que proporciona nombres personalizados para analizadores de volcado de subprocesos. Por lo general, solo doy tf=nullpara reutilizar la fábrica de hilos predeterminada de JVM. Este sitio web tiene una fábrica de hilos más avanzada.

public class SimpleThreadFactory implements ThreadFactory {
    private ThreadFactory tf;
    private String nameSuffix;

    public SimpleThreadFactory (ThreadFactory tf, String nameSuffix) {
        this.tf = tf!=null ? tf : Executors.defaultThreadFactory();
        this.nameSuffix = nameSuffix; 
    }

    @Override public Thread newThread(Runnable task) {
        // default "pool-1-thread-1" to "pool-1-thread-1-myapp-MagicTask"
        Thread thread=tf.newThread(task);
        thread.setName(thread.getName()+"-"+nameSuffix);
        return thread;
    }
}

- - - - - 

ExecutorService es = Executors.newFixedThreadPool(4, new SimpleThreadFactory(null, "myapp-MagicTask") );

Para su comodidad, este es un bucle de volcado de subprocesos para fines de depuración.

    ThreadMXBean mxBean=ManagementFactory.getThreadMXBean();
    long[] tids = mxBean.getAllThreadIds();
    System.out.println("------------");
    System.out.println("ThreadCount="+tids.length);
    for(long tid : tids) {
        ThreadInfo mxInfo=mxBean.getThreadInfo(tid);
        if (mxInfo==null) {
            System.out.printf("%d %s\n", tid, "Thread not found");
        } else {
            System.out.printf("%d %s, state=%s, suspended=%d, lockowner=%d %s\n"
                    , mxInfo.getThreadId(), mxInfo.getThreadName()
                    , mxInfo.getThreadState().toString()
                    , mxInfo.isSuspended()?1:0
                    , mxInfo.getLockOwnerId(), mxInfo.getLockOwnerName()
            );
        }
    }