【转】创建线程以及线程池时候要指定与业务相关的名字，以便于追溯问题

原文：https://www.jianshu.com/p/d6245f2c3a9d

3.9 创建线程以及线程池时候要指定与业务相关的名字，以便于追溯问题

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

3.9.1创建线程需要带线程名

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

 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并且启动执行运行上面代码可能会输出如下：

image.png

从运行接口可知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进行同步。

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

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

    }

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

image.png

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

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

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

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

运行代码输出如下结果：

同理我们并不知道是那个模块的线程池抛出了这个异常，那么我们看下这个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;
        }
    }

如上代码DefaultThreadFactory的实现可知:

• 代码（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()拼接的。

从上知道我们只需对实现ThreadFactory并对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"));

然后运行执行结果如下：

image.png

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

3.9.3总结

本节通过简单的例子介绍了为何不给线程或者线程池起名字会给问题排查带来麻烦，然后通过源码原理介绍线程和线程池名称是默认名称是如何来的，以及如何自定义线程池名称，以便问题追溯。