假设我有一个利用Executor框架的应用程序
Executors.newSingleThreadExecutor().submit(new Runnable(){
@Override
public void run(){
// do stuff
}
}
当我在调试器中运行此应用程序时，将创建一个具有以下(默认)名称的线程:thread [pool-1-thread-1]。正如您所看到的，这并不是非常有用，而且据我所知，Executor框架并没有提供一种简单的方法来命名创建的线程或线程池。
那么，如何为线程/线程池提供名称呢?例如，Thread[fopool - foothread]。
当前回答
正如其他答案已经说过的，您可以创建并使用自己的java.util.concurrent.ThreadFactory接口的实现(不需要外部库)。 我把我的代码粘贴在下面，因为它不同于以前的答案，因为它使用字符串。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);
编辑:使我的ThreadFactory实现线程安全，感谢@mchernyakov指出这一点。 尽管在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)));
}
}
其他回答
一个快速而肮脏的方法是使用Thread.currentThread().setName(myName);在run()方法中。
正如其他答案已经说过的，您可以创建并使用自己的java.util.concurrent.ThreadFactory接口的实现(不需要外部库)。 我把我的代码粘贴在下面，因为它不同于以前的答案，因为它使用字符串。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);
编辑:使我的ThreadFactory实现线程安全，感谢@mchernyakov指出这一点。 尽管在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)));
}
}
您可以编写自己的ThreadFactory实现，例如使用一些现有的实现(如defaultThreadFactory)，并在最后更改名称。
实现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;
}
}
和用法:
Executors.newSingleThreadExecutor(new ThreadFactoryWithCustomName(
Executors.defaultThreadFactory(),
"customName")
);
Oracle对此有一个开放的RFE。从甲骨文员工的评论来看，他们似乎不理解这个问题，也不会解决。在JDK中支持它是非常简单的事情之一(不会破坏向后兼容性)，所以RFE被误解有点遗憾。
如前所述，您需要实现自己的ThreadFactory。如果您不想为了这个目的而引入Guava或Apache Commons，我在这里提供一个ThreadFactory实现供您使用。除了能够将线程名前缀设置为“pool”之外，它与您从JDK中获得的内容完全相似。
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这一事实。
This
Executors.newSingleThreadExecutor();
将给出一个ExecutorService，其中线程命名为pool-N-thread-M，但使用
Executors.newSingleThreadExecutor(new ThreadFactoryWithNamePrefix("primecalc"));
您将得到一个ExecutorService，其中线程名为primecalc-N-thread-M。瞧!
ThreadFactory扩展
公共接口
根据需要创建新线程的对象。使用线程工厂消除了对新线程的硬连接，使应用程序能够使用特殊的线程子类、优先级等。
线程newThread(可运行r)
构造一个新的线程。实现也可以初始化优先级、名称、守护进程状态、线程组等。
示例代码:
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();
}
}
输出:
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
等
