在日常开发中，当在一个应用中需要创建多个线程或者线程池时最好给每个线程或者线程池根据业务类型设置具体的名称，以便在出现问题时方便进行定位。下面就通过实例来说明不设置为何难以定位问题，以及如何进行设置。

创建线程需要有线程名

下面通过简单的代码来说明不指定线程名称为何难定位问题，代码如下。

    public static void main（String[] args） {
      //订单模块 
        Thread threadOne = new Thread(new Runnable() {
            public void run() {
                System.out.println（「保存订单的线程」）；
                try {
                    Thread.sleep(500)；
                } catch （InterruptedException e） {
                    e.printStackTrace()；
                }
                throw new NullPointerException()；
            }
        })；
     //发货模块 
        Thread threadTwo = new Thread(new Runnable() {
            public void run() {
                System.out.println（「保存收获地址的线程」）；
            }
        })；
        threadOne.start()；
        threadTwo.start()；
    }

如上代码分别创建了线程 one 和线程 two，运行上面的代码，输出如下。

创建线程和线程池时要指定与业务相关的名称 - 图1

从运行结果可知，Thread-0 抛出了 NPE 异常，那么单看这个日志根本无法判断是订单模块的线程抛出的异常。首先我们分析下这个 Thread-0 是怎么来的，我们看一下创建线程时的代码。

    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize) {
        init(g, target, name, stackSize, null);
    }

由这段代码可知，如果调用没有指定线程名称的方法创建线程，其内部会使用「Thread-」+ nextThreadNum（）作为线程的默认名称，其中 nextThreadNum 的代码如下。

    private static int threadInitNumber;
    private static synchronized int nextThreadNum() {
        return threadInitNumber++;
    }

由此可知，threadInitNumber 是 static 变量，nextThreadNum 是 static 方法，所以线程的编号是全应用唯一的并且是递增的。这里由于涉及多线程递增 threadInitNumber，也就是执行读取—递增—写入操作，而这是线程不安全的，所以要使用方法级别的 synchronized 进行同步。

当一个系统中有多个业务模块而每个模块又都使用自己的线程时，除非抛出与业务相关的异常，否则你根本没法判断是哪一个模块出现了问题。现在修改代码如下。

    static final String THREAD_SAVE_ORDER = 「THREAD_SAVE_ORDER」；
    static final String THREAD_SAVE_ADDR = 「THREAD_SAVE_ADDR」；
    public static void main（String[] args） {
        // 订单模块 
        Thread threadOne = new Thread(new Runnable() {
            public void run() {
                System.out.println（「保存订单的线程」）；
                throw new NullPointerException()；
            }
        }， THREAD_SAVE_ORDER)；
        // 发货模块 
        Thread threadTwo = new Thread(new Runnable() {
            public void run() {
                System.out.println（「保存收货地址的线程」）；
            }
        }， THREAD_SAVE_ADDR)；
        threadOne.start()；
        threadTwo.start()；
    }

如上代码在创建线程时给线程指定了一个与具体业务模块相关的名称，运行代码，输出结果为

创建线程和线程池时要指定与业务相关的名称 - 图2

从运行结果就可以定位到是保存订单模块抛出了 NPE 异常，一下子就可以找到问题所在。

创建线程池时也需要指定线程池的名称

同理，下面通过简单的代码来说明不指定线程池名称为何难定位问题，代码如下。

    static ThreadPoolExecutor executorOne = new ThreadPoolExecutor（5, 5, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<>()）；
    static ThreadPoolExecutor executorTwo = new ThreadPoolExecutor（5, 5, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<>()）；
    public static void main（String[] args） {
        //接受用户链接模块 
        executorOne.execute(new  Runnable() {
            public void run() {
                System.out.println（「接受用户链接线程」）；
                throw new NullPointerException()；
            }
        })；
        //具体处理用户请求模块 
        executorTwo.execute(new  Runnable() {
            public void run() {
                System.out.println（「具体处理业务请求线程」）；
            }
        })；
        executorOne.shutdown()；
        executorTwo.shutdown()；
    }

运行代码，输出结果如下。

创建线程和线程池时要指定与业务相关的名称 - 图3

同样，我们并不知道是哪个模块的线程池抛出了这个异常，那么我们看下这个 pool-1-thread-1 是如何来的。其实这里使用了线程池默认的 ThreadFactory，查看线程池创建的源码如下。

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
            Executors.defaultThreadFactory(), defaultHandler);
    }
   public static ThreadFactory defaultThreadFactory() {
   return new DefaultThreadFactory();
    }
  static class DefaultThreadFactory implements ThreadFactory {
        //(1)
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        //(2)
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        //(3)
        private final String namePrefix;
        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s ! = null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                        "-thread-";
        }
        public Thread newThread(Runnable r) {
          //(4)
            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;
        }
    }

代码（1）中的 poolNumber 是 static 的原子变量，用来记录当前线程池的编号，它是应用级别的，所有线程池共用一个，比如创建第一个线程池时线程池编号为 1，创建第二个线程池时线程池的编号为 2，所以 pool-1-thread-1 里面的 pool-1 中的 1 就是这个值。

代码（2）中的 threadNumber 是线程池级别的，每个线程池使用该变量来记录该线程池中线程的编号，所以 pool-1-thread-1 里面的 thread-1 中的 1 就是这个值。

代码（3）中的 namePrefix 是线程池中线程名称的前缀，默认固定为 pool。

代码（4）具体创建线程，线程的名称是使用 namePrefix + threadNumber. getAndIncrement（）拼接的。

由此我们知道，只需对 DefaultThreadFactory 的代码中的 namePrefix 的初始化做下手脚，即当需要创建线程池时传入与业务相关的 namePrefix 名称就可以了，代码如下。

    // 命名线程工厂 
static class NamedThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1)；
        private final ThreadGroup group；
        private final AtomicInteger threadNumber = new AtomicInteger(1)；
        private final String namePrefix；
        NamedThreadFactory（String name） {
            SecurityManager s = System.getSecurityManager()；
            group = （s ! = null） ？ s.getThreadGroup() : Thread.currentThread().
              getThreadGroup()；
            if （null == name || name.isEmpty()） {
                name = 「pool」；
            }
            namePrefix = name + 「-」 + poolNumber.getAndIncrement() + 「-thread-」；
        }
        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；
        }
}

创建线程池如下。

static ThreadPoolExecutor executorOne = new ThreadPoolExecutor(5, 5, 1,
            TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(), new NamedThreadFactory("ASYN-ACCEPT-POOL"));
static ThreadPoolExecutor executorTwo = new ThreadPoolExecutor(5, 5, 1,
            TimeUnit.MINUTES,
            new LinkedBlockingQueue<>(), new NamedThreadFactory("ASYN-PROCESS-POOL"));

执行结果如下。

创建线程和线程池时要指定与业务相关的名称 - 图4

从 ASYN-ACCEPT-POOL-1-thread-1 就可以知道，这是接受用户链接线程池抛出的异常。

小结

本节通过简单的例子介绍了为何不为线程或者线程池起名字会给问题排查带来麻烦，然后通过源码分析介绍了线程和线程池名称及默认名称是如何来的，以及如何定义线程池名称以便追溯问题。另外，在 run 方法内使用 try-catch 块，避免将异常抛到 run 方法之外，同时打印日志也是一个最佳实践。