Nommer les threads et les pools de threads d'ExecutorService

Disons que j'ai une application qui utilise le Executorcadre en tant que tel

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

Quand je lance cette application dans le débogueur, un thread est créé avec le nom suivant (par défaut): Thread[pool-1-thread-1]. Comme vous pouvez le voir, ce n'est pas très utile et pour autant que je sache, le Executorcadre ne fournit pas un moyen facile de nommer les threads ou les pools de threads créés.

Alors, comment peut-on fournir des noms pour les threads / thread-pools? Par exemple, Thread[FooPool-FooThread].

Vous pourriez fournir un ThreadFactoryà newSingleThreadScheduledExecutor(ThreadFactory threadFactory). L'usine sera responsable de la création des threads et pourra les nommer.

Pour citer le Javadoc :

Créer de nouveaux threads

De nouveaux threads sont créés à l'aide d'un ThreadFactory. Sauf indication contraire, a Executors.defaultThreadFactory()est utilisé, ce qui crée des threads pour qu'ils soient tous identiques ThreadGroupet avec le même NORM_PRIORITYstatut de priorité et de non-démon. En fournissant un autre ThreadFactory, vous pouvez modifier le nom du fil, groupe de threads, la priorité, le statut démon, etc. Si un ThreadFactoryne parvient pas à créer un fil quand on lui demande en retournant nul de newThread, l'exécuteur testamentaire continuera, mais peut - être pas en mesure d'exécuter toutes les tâches

La goyave a presque toujours ce dont vous avez besoin .

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

et le passer à votre ExecutorService.

Vous pouvez essayer de fournir votre propre fabrique de threads, qui créera un thread avec les noms appropriés. Voici un exemple:

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

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

Vous pouvez également modifier le nom de votre thread par la suite, pendant l'exécution du thread:

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

Cela pourrait être intéressant si, par exemple, vous utilisez la même ThreadFactory pour différents types de tâches.

le BasicThreadFactory apache commons-lang est également utile pour fournir le comportement de dénomination. Au lieu d'écrire une classe interne anonyme, vous pouvez utiliser le générateur pour nommer les threads comme vous le souhaitez. Voici l'exemple des 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 vous utilisez Spring, CustomizableThreadFactoryvous pouvez définir un préfixe de nom de thread.

Exemple:

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

Alternativement, vous pouvez créer votre en ExecutorServicetant que bean Spring en utilisant ThreadPoolExecutorFactoryBean- alors les threads seront tous nommés avec le beanName-préfixe.

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

Dans l'exemple ci-dessus, les threads seront nommés avec myExecutor-préfixe. Vous pouvez définir le préfixe explicitement sur une valeur différente (par exemple. "myPool-") En définissant executorFactoryBean.setThreadNamePrefix("myPool-")le bean d'usine.

Il existe un RFE ouvert pour cela avec Oracle. D'après les commentaires de l'employé Oracle, il semble qu'ils ne comprennent pas le problème et ne le résoudront pas. C'est une de ces choses qui est très simple à prendre en charge dans le JDK (sans briser la compatibilité descendante), donc c'est une sorte de honte que le RFE soit mal compris.

Comme indiqué, vous devez implémenter votre propre ThreadFactory . Si vous ne voulez pas utiliser Guava ou Apache Commons uniquement à cette fin, je fournis ici une ThreadFactoryimplémentation que vous pouvez utiliser. Il est exactement similaire à ce que vous obtenez du JDK, à l'exception de la possibilité de définir le préfixe du nom du thread sur autre chose 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;
    }
}

Lorsque vous souhaitez l'utiliser, vous profitez simplement du fait que toutes les Executorsméthodes vous permettent de fournir la vôtre ThreadFactory.

Ce

    Executors.newSingleThreadExecutor();

donnera un ExecutorService où les threads sont nommés pool-N-thread-Mmais en utilisant

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

vous obtiendrez un ExecutorService où les threads sont nommés 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;
    }

}

Passez la ThreadFactory à un service d'exécution et vous êtes prêt à partir

Un moyen rapide et sale est d'utiliser Thread.currentThread().setName(myName);dans la run()méthode.

Étendre ThreadFactory

public interface ThreadFactory

Un objet qui crée de nouveaux threads à la demande. L'utilisation des usines de threads supprime le câblage des appels vers le nouveau thread, permettant aux applications d'utiliser des sous-classes de threads spéciales, des priorités, etc.

Thread newThread(Runnable r)

Construit un nouveau thread. Les implémentations peuvent également initialiser la priorité, le nom, l'état du démon, ThreadGroup, etc.

Exemple de code:

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

production:

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

Comme d'autres réponses l'ont déjà dit, vous pouvez créer et utiliser votre propre implémentation de l' java.util.concurrent.ThreadFactoryinterface (aucune bibliothèque externe requise). Je colle mon code ci-dessous car il est différent des réponses précédentes car il utilise la String.formatméthode et prend un nom de base pour les threads comme argument constructeur:

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

Et ceci est un exemple d'utilisation:

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

EDIT : rendre mon ThreadFactoryimplémentation thread-safe, merci à @mchernyakov de l' avoir signalé.
Même si nulle part dans la ThreadFactorydocumentation il n'est dit que ses implémentations doivent être thread-safe, le fait que le DefaultThreadFactorythread-safe soit un indice important:

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 solution Java de base que j'utilise pour décorer les usines existantes:

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 action:

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

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

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

Vous pouvez écrire votre propre implémentation de ThreadFactory, en utilisant par exemple une implémentation existante (comme defaultThreadFactory) et changer le nom à la fin.

Exemple d'implémentation 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;
    }
}

Et l'utilisation:

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

J'utilise pour faire la même chose comme ci-dessous (nécessite une guavabibliothèque):

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

Je trouve plus facile d'utiliser un lambda comme fabrique de threads si vous voulez simplement changer le nom d'un exécuteur de thread unique.

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

Ceci est mon usine personnalisée fournissant des noms personnalisés pour les analyseurs de vidage de thread. Habituellement, je donne juste tf=nullpour réutiliser la fabrique de threads par défaut JVM. Ce site Web a une usine de threads plus avancée.

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") );

Pour votre commodité, il s'agit d'une boucle de vidage de thread à des fins de débogage.

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