Nazewnictwo wątków i pul wątków w ExecutorService

Załóżmy, że mam aplikację, która korzysta z Executorframeworka jako takiego

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

Kiedy uruchomić tę aplikację w debugger, wątek jest tworzony z poniższej (domyślnie) imię: Thread[pool-1-thread-1]. Jak widać, nie jest to szczególnie przydatne i, o ile mogę stwierdzić, Executorframework nie zapewnia łatwego sposobu nazwania utworzonych wątków lub pul wątków.

Jak zatem można podać nazwy wątków / pul wątków? Na przykład Thread[FooPool-FooThread].

Możesz podać ThreadFactorydo newSingleThreadScheduledExecutor(ThreadFactory threadFactory). Fabryka będzie odpowiedzialna za tworzenie wątków i będzie mogła je nazwać.

Cytując Javadoc :

Tworzenie nowych wątków

Nowe wątki są tworzone za pomocą ThreadFactory. Jeśli nie określono inaczej, Executors.defaultThreadFactory()używana jest a , która tworzy wątki, aby wszystkie miały ten sam ThreadGroupi miały ten sam NORM_PRIORITYpriorytet i ten sam status demona. Podając inny ThreadFactory, możesz zmienić nazwę wątku, grupę wątków, priorytet, status demona itp. Jeśli ThreadFactoryutworzenie wątku nie powiedzie się, gdy zostaniesz o to poproszony poprzez zwrócenie wartości null od newThread, executor będzie kontynuował, ale może nie być w stanie wykonać żadnych zadań

Guawa prawie zawsze ma to, czego potrzebujesz .

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

i przekaż to swojemu ExecutorService.

Możesz spróbować stworzyć własną fabrykę wątków, która utworzy wątek o odpowiednich nazwach. Oto jeden przykład:

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

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

Możesz także później zmienić nazwę swojego wątku, gdy wątek jest wykonywany:

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

Może to być interesujące, jeśli na przykład używasz tego samego ThreadFactory do różnego rodzaju zadań.

Z BasicThreadFactoryapache commons-lang jest także przydatny do zapewnienia zachowania nazewnictwa. Zamiast pisać anonimową klasę wewnętrzną, możesz użyć Konstruktora, aby nazwać wątki według własnego uznania. Oto przykład z 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);

Jeśli używasz Spring, CustomizableThreadFactorymożesz ustawić prefiks nazwy wątku.

Przykład:

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

Alternatywnie możesz utworzyć ExecutorServicefasolę wiosenną za pomocą ThreadPoolExecutorFactoryBean- wtedy wszystkie wątki zostaną nazwane z beanName-prefiksem.

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

W powyższym przykładzie wątki zostaną nazwane myExecutor-przedrostkiem. Możesz jawnie ustawić prefiks na inną wartość (np. "myPool-"), Ustawiając executorFactoryBean.setThreadNamePrefix("myPool-")na fasolę fabryczną.

Jest do tego otwarty RFE z Oracle. Z komentarzy pracownika Oracle wynika, że ​​nie rozumieją problemu i nie mogą go naprawić. Jest to jedna z tych rzeczy, które są bardzo proste w obsłudze w JDK (bez naruszania kompatybilności wstecznej), więc wstydem jest to, że RFE zostało źle zrozumiane.

Jak wskazano, musisz wdrożyć własny ThreadFactory . Jeśli nie chcesz pobierać Guava lub Apache Commons tylko w tym celu, podaję ThreadFactoryimplementację, z której możesz skorzystać. Jest dokładnie podobny do tego, co otrzymujesz z JDK, z wyjątkiem możliwości ustawienia prefiksu nazwy wątku na coś innego niż „pula”.

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

Kiedy chcesz z niego skorzystać, po prostu skorzystaj z faktu, że wszystkie Executorsmetody pozwalają na zapewnienie własnych ThreadFactory.

To

    Executors.newSingleThreadExecutor();

da ExecutorService, gdzie wątki są nazywane, pool-N-thread-Male przy użyciu

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

dostaniesz ExecutorService, gdzie są nazywane wątki 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;
    }

}

Przekaż ThreadFactory do executorservice i możesz zacząć

Szybkim i brudnym sposobem jest użycie Thread.currentThread().setName(myName);tej run()metody.

Rozszerz ThreadFactory

public interface ThreadFactory

Obiekt, który tworzy nowe wątki na żądanie. Korzystanie z fabryk wątków eliminuje konieczność wykonywania połączeń do nowego wątku, umożliwiając aplikacjom korzystanie ze specjalnych podklas wątków, priorytetów itp.

Thread newThread(Runnable r)

Tworzy nowy wątek. Implementacje mogą również inicjować priorytet, nazwę, status demona, ThreadGroup itp.

Przykładowy kod:

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

wynik:

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

....itp

Jak już powiedziano w innych odpowiedziach, możesz utworzyć własną implementację java.util.concurrent.ThreadFactoryinterfejsu i korzystać z niej (nie są wymagane biblioteki zewnętrzne). Wklejam poniższy kod, ponieważ różni się on od poprzednich odpowiedzi, ponieważ używa String.formatmetody i przyjmuje podstawową nazwę wątków jako argument konstruktora:

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

A to jest przykład użycia:

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

EDYCJA : dzięki czemu moja ThreadFactoryimplementacja jest bezpieczna dla wątków, dzięki @mchernyakov za wskazanie tego.
Chociaż nigdzie w ThreadFactorydokumentacji nie jest powiedziane, że jego implementacje muszą być bezpieczne dla wątków, fakt, że DefaultThreadFactoryjest bezpieczny dla wątków, stanowi dużą wskazówkę:

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

Domowe podstawowe rozwiązanie Java, którego używam do ozdabiania istniejących fabryk:

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

W akcji:

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

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

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

Możesz napisać własną implementację ThreadFactory, używając na przykład niektórych istniejących implementacji (takich jak defaultThreadFactory) i zmienić nazwę na końcu.

Przykład implementacji 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;
    }
}

I użycie:

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

Używam tego samego, co poniżej (wymaga guavabiblioteki):

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

Uważam, że najłatwiej jest użyć lambda jako fabryki wątków, jeśli chcesz tylko zmienić nazwę dla jednego modułu wykonującego wątek.

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

To moja spersonalizowana fabryka zapewniająca niestandardowe nazwy analizatorów zrzutów wątków. Zwykle po prostu daję tf=nullponownie użyć domyślnej fabryki wątków JVM. Ta strona ma bardziej zaawansowaną fabrykę wątków.

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

Dla Twojej wygody jest to pętla zrzutu wątku do celów debugowania.

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