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

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

    }

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

从运行结果就可以定位到是保存订单模块抛出了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总结

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

——————————–相约GitChat探讨技术————————————–

一、常用开源框架 Spring 和 Tomcat 扩展接口揭秘

评价一个框架是否优秀,其中必有一点是看该框架是否留足了可扩展的接口。我们在实际做项目或者研发框架时,很多情况下就是在框架留出的扩展接口上进行定制,所以很有必要对这些框架留出了哪些扩展点,这些扩展点是干啥用的有个心知肚明的了解。

本 Chat 将针对 Spring 和 Tomcat 扩展点进行介绍,主要内容包括:

  • 对 Spring 框架在容器刷新(Refresh 阶段),创建 Bean(getBean),容器销毁(destory)阶段中的扩展接口进行讲解;
  • 对 Tomcat 中的 ContextLoaderListener 扩展接口进行讲解,并讲解 Webx 框架和 SpringMVC 框架如何使用它,从而让 Tomcat 与应用框架联系起来。
 二、SpringBoot核心模块原理分析Chat

最近微服务很火,SpringBoot 以其轻量级,内嵌 Web 容器,一键启动,方便调试等特点被越来越多的微服务实践者所采用。然而知其然还要知其所以然,本节就来讲解 SpringBoot 的核心模块的实现原理,这些内容在面试的时候也是会被经常问到的:

  • spring-boot-load 模块,正常情况下一个类加载器只能找到加载路径的jar包里面当前目录或者文件类里面的*.class文件,SpringBoot 允许我们使用 java -jar archive.jar 运行包含嵌套依赖 jar 的 jar 或者 war 文件,那么 SpringBoot 是如何实现的那?
  • spring-boot-autoconfigure 模块,Auto-configuration 是 SpringBoot 在 Spring 的基础上提供的一个自动扫描 jar 包里面指定注解的类并注入到 Spring 容器的功能组件。
  • spring-boot 模块,提供了一些特性用来支持 SpringBoot 中其它模块。欢迎长按识别二维码加入本chat
  • 欢迎长按识别二维码加入本chat
image.png
image.png

三、Java 类加载器揭秘Chat

类加载器作为 JVM 加载字节码到内存中的媒介,其重要性不言而喻,另外在职场面试时候也会被频繁的问道,了解类加载器的原理,能灵活的自定义类加载器去实现自己的功能显得尤为重要。

主要内容:

  • 讲解 Java 中自带的三种类加载器,以及构造原理
  • 讲解类加载器原理
  • 讲解一种特殊的与线程相关类加载器
  • 讲解 Tomcat 框架中多级类加载器的实现原理
  • 讲解如何自定义类加载器实现模块隔离欢迎长按识别二维码加入本chat
加多

加多

高级 Java 攻城狮 at 阿里巴巴
加多,目前就职于阿里巴巴,热衷并发编程、ClassLoader,Spring等开源框架,分布式RPC框架dubbo,springcloud等;爱好音乐,运动。微信公众号:技术原始积累。知识星球账号:技术原始积累
加多

Latest posts by 加多 (see all)

FavoriteLoading添加本文到我的收藏
  • Trackback 关闭
  • 评论 (0)
  1. 暂无评论

您必须 登陆 后才能发表评论

return top