假设我有一个应用程序，它像这样利用了Executor框架
Executors.newSingleThreadExecutor().submit(new Runnable(){
@Override
public void run(){
// do stuff
}
}
Thread [pool-1-thread-1]（默认名称）。正如您所见，这并不是非常有用的，并且据我所知，Executor框架没有提供一种简单的方式来为创建的线程或线程池命名。Thread [FooPool-FooThread]。Guava几乎总是拥有你需要的东西。
ThreadFactory namedThreadFactory =
new ThreadFactoryBuilder().setNameFormat("my-sad-thread-%d").build()
并将其传递给您的ExecutorService。
newSingleThreadScheduledExecutor(ThreadFactory threadFactory)提供一个ThreadFactory。该工厂将负责创建线程，并能够对其进行命名。创建新线程
使用
ThreadFactory来创建新线程。如果未明确指定，则使用Executors.defaultThreadFactory()，它创建的所有线程都在同一ThreadGroup中，并具有相同的NORM_PRIORITY优先级和非守护进程状态。您可以通过提供不同的ThreadFactory来更改线程的名称、线程组、优先级、守护进程状态等。如果ThreadFactory无法成功创建线程并从newThread返回null时被请求，则执行者将继续执行，但可能无法执行任何任务。
您可以尝试提供自己的线程工厂，以创建带有适当名称的线程。以下是一个示例：
class YourThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
return new Thread(r, "Your name");
}
}
Executors.newSingleThreadExecutor(new YourThreadFactory()).submit(someRunnable);
或者在 Kotlin 中
Executors.newSingleThreadExecutor { r -> Thread(r, "Your name") }
在执行线程的同时，您也可以随后更改线程的名称：
Thread.currentThread().setName("FooName");
如果你正在为不同类型的任务使用相同的ThreadFactory，那么这可能会很有趣。
(请注意，如果此单个线程在关闭之前由于执行期间发生故障而终止，则如有需要，将创建一个新线程来执行后续任务。)。如果ExecutorService替换了该线程，它将由ThreadFactory命名。不过，在调试时看到名称消失可能是一个有用的指示器。 - sethro来自 Apache Commons-Lang 的 BasicThreadFactory 也可以用于提供命名行为。你可以使用 Builder 来按照你的意愿对线程进行命名，而不是编写匿名内部类。以下是 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);
CustomizableThreadFactory，并设置线程名称前缀。ExecutorService alphaExecutor =
Executors.newFixedThreadPool(10, new CustomizableThreadFactory("alpha-"));
或者，您可以使用ThreadPoolExecutorFactoryBean将您的ExecutorService创建为Spring bean - 然后所有线程都将以beanName-前缀命名。
@Bean
public ThreadPoolExecutorFactoryBean myExecutor() {
ThreadPoolExecutorFactoryBean executorFactoryBean = new ThreadPoolExecutorFactoryBean();
// configuration of your choice
return executorFactoryBean;
}
myExecutor-前缀命名。您可以通过在工厂bean上设置executorFactoryBean.setThreadNamePrefix("myPool-")来显式地将前缀设置为其他值（例如"myPool-"）。在Oracle中有一个与此相关的开放式RFE。从Oracle员工的评论中可以看出，他们不理解这个问题，也不会修复它。这是JDK中非常简单的支持方式之一（不会破坏向后兼容性），所以很遗憾这个RFE被误解了。
正如所指出的那样，您需要自己实现ThreadFactory。如果您不想为此目的引入Guava或Apache Commons，我在这里提供了一个ThreadFactory实现，您可以使用它。它与您从JDK中获得的完全相似，只是可以将线程名称前缀设置为其他内容而不是“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;
}
}
Executors方法允许您提供自己的ThreadFactory这一事实。 Executors.newSingleThreadExecutor();
这段代码会返回一个ExecutorService，其中线程的名称将为pool-N-thread-M，但是可以通过使用
Executors.newSingleThreadExecutor(new ThreadFactoryWithNamePrefix("primecalc"));
primecalc-N-thread-M。大功告成！ThreadPoolExecutor 而不是 ThreadGroup。 - Drakes正如其他答案已经提到的，您可以创建并使用自己实现的java.util.concurrent.ThreadFactory接口（无需外部库）。
我在下面粘贴了我的代码，因为它与以前的答案不同，它使用String.format方法并将线程的基本名称作为构造函数参数：
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));
}
}
这是一个使用示例：
ThreadFactory threadFactory = new NameableThreadFactory("listenerThread");
final ExecutorService executorService = Executors.newFixedThreadPool(5, threadFactory);
编辑：感谢@mchernyakov指出，使我的ThreadFactory实现线程安全。
尽管ThreadFactory文档中没有提到其实现必须是线程安全的，但DefaultThreadFactory是线程安全的事实是一个很大的提示：
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)));
}
}
如果您只想为单个线程执行器更改名称，我发现使用 Lambda 作为线程工厂最容易。
Executors.newSingleThreadExecutor(runnable -> new Thread(runnable, "Your name"));
main@1、Finalizer@667、Reference Handler@668、Your name@665、Signal Dispatcher@666。 - CamW一种快速简单的方法是在run()方法中使用Thread.currentThread().setName(myName);。