Benennen von Threads und Thread-Pools von ExecutorService

Guave fast immer hat das, was Sie müssen.

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

, und übergeben Sie es aus, um Ihre ExecutorService.

InformationsquelleAutor der Antwort pathikrit

Können Sie auch ändern Sie den Namen von deinem thread danach, während der thread ausgeführt wird:

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

Könnte von Interesse sein, wenn zum Beispiel bist du mit dem gleichen ThreadFactory für verschiedene Arten von Aufgaben.

InformationsquelleAutor der Antwort FlorianT

Gibt es eine öffnen RFE für diese mit Oracle. Aus den Bemerkungen, die aus der Oracle-Mitarbeiter, es scheint Sie don ' T verstehen das Problem und nicht zu beheben. Es ist eines dieser Dinge, die ist tot einfach, um Unterstützung für das JDK (ohne brechen der Rückwärtskompatibilität), so ist es irgendwie schade, dass die RFE bekommt missverstanden.

Als Spitzen aus, die Sie benötigen, um Ihre eigenen ThreadFactory. Wenn Sie nicht wollen, ziehen Sie in Guava oder Apache Commons, nur für diesen Zweck, die ich bieten hier eine ThreadFactory Implementierung, die Sie verwenden können. Es ist genau das, ähnlich wie das, was Ihr aus dem JDK, mit Ausnahme Sie die Möglichkeit, die thread-Namen-Präfix etwas anderes als "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;
    }
}

Wenn Sie wollen, es zu benutzen Sie einfach die Tatsache zunutze, dass alle Executors Methoden können Sie Ihre eigenen ThreadFactory.

Diese

    Executors.newSingleThreadExecutor();

gibt einen ExecutorService, wo threads benannt sind pool-N-thread-M aber mit

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

erhalten Sie einen ExecutorService, wo threads benannt sind primecalc-N-thread-M. Voila!

InformationsquelleAutor der Antwort peterh

private class TaskThreadFactory implements ThreadFactory
{

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

        return t;
    }

}

Pass die ThreadFactory an einen executorservice und Sie sind gut zu gehen

InformationsquelleAutor der Antwort I.Tyger

Erweitern ThreadFactory

public interface ThreadFactory

Einem Objekt, erstellt neue threads auf Nachfrage. Mit thread-Fabriken entfernt festverdrahtung der Anrufe zum neuen Thread, ermöglicht Anwendungen die Verwendung von speziellen, thread-Unterklassen, Prioritäten, etc.

Thread newThread(Runnable r)

Erstellt einen neuen Thread. Implementierungen können auch initialisieren, Priorität, name, daemon-status, ThreadGroup, etc.

Beispielcode:

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

Ausgabe:

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

InformationsquelleAutor der Antwort Ravindra babu

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

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

InformationsquelleAutor der Antwort many mny