禅与计算机
sharkchili
2026-03-25
目录

浅谈守护线程与进程优雅关闭

# 引言

本文原本是针对守护线程的一些探讨，感觉知识点稍显浅薄，故基于原有文章进行迭代补充对于Java程序优雅关闭的一些思考。

我是 SharkChili ，Java 开发者，Java Guide 开源项目维护者。欢迎关注我的公众号：写代码的SharkChili，也欢迎您了解我的开源项目 mini-redis：https://github.com/shark-ctrl/mini-redis (opens new window)。

为方便与读者交流，现已创建读者群。关注上方公众号获取我的联系方式，添加时备注加群即可加入。

# JVM中的关闭

# 详解虚拟机钩子

在Java进程开发中，对于重量级的系统资源关闭或者进程资源整理或信号输出，常常会通过Java内置的addShutdownHook方法注册回调函数，确保在Java进程关闭不再使用这些资源时将其释放，例如hutool这个工具类对应连接池的管理工具GlobalDSFactory，其底层就会在类加载初始化时利用addShutdownHook注册一个连接池销毁的回调函数：

/*
	 * 设置在JVM关闭时关闭所有数据库连接
	 */
	static {
		// JVM关闭时关闭所有连接池
		Runtime.getRuntime().addShutdownHook(new Thread() {
			@Override
			public void run() {
				if (null != factory) {
					factory.destroy();
					StaticLog.debug("DataSource: [{}] destroyed.", factory.dataSourceName);
					factory = null;
				}
			}
		});
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

而虚拟机钩子注册的原理本质上就是在调用addShutdownHook时，其底层将这个现场hook注册到一个hooks的map容器中，并在shutdown的时候遍历调用这些hook线程：

对应的我们也给出addShutdownHook的实现，可以看到其底层就是调用ApplicationShutdownHooks来注册hook：

 public void addShutdownHook(Thread hook) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new RuntimePermission("shutdownHooks"));
        }
   			//将hook注册到底层的hoooks这个map中
        ApplicationShutdownHooks.add(hook);
    }
1
2
3
4
5
6
7
8

而步入这个add方法后可以看到其内部本质上就是在必要的校验后，存入到hooks这个map中：


private static IdentityHashMap<Thread, Thread> hooks;

static synchronized void add(Thread hook) {
        //......

        hooks.put(hook, hook);
    }
1
2
3
4
5
6
7
8

当触发虚拟机钩子关闭时，其内部就会针对hooks进行遍历并按照如下逻辑处理：

  1. 将hook线程启动，执行hook逻辑
  2. 调用join确保该hook能够准确执行完成
static void runHooks() {
        Collection<Thread> threads;
        synchronized(ApplicationShutdownHooks.class) {
            threads = hooks.keySet();
            hooks = null;
        }
		//遍历hook线程启动
        for (Thread hook : threads) {
            hook.start();
        }
        for (Thread hook : threads) {
            while (true) {
                try {
                //调用join加入主线程确保当前线程能够正确执行完成
                    hook.join();
                    break;
                } catch (InterruptedException ignored) {
                }
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

当所有关闭钩子都执行结束时，如果runFinalizersOnExit为true，那么JVM就会运行终结器finalizers，此时JVM并不会停止或者关闭仍然在运行的应用线程。直到最终JVM结束，应用线程才会被关闭，对应的我们可以在源码Shutdown的exit方法印证：

static void exit(int status) {
        boolean runMoreFinalizers = false;
        synchronized (lock) {
            	//......
            case FINALIZERS:
                if (status != 0) {
                    /* Halt immediately on nonzero status */
                    halt(status);
                } else {
                   //......
                   //将runFinalizersOnExit赋值给runMoreFinalizers 
                    runMoreFinalizers = runFinalizersOnExit;
                }
                break;
            }
        }
        //如果runMoreFinalizers 为true，则运行终结器
        if (runMoreFinalizers) {
            runAllFinalizers();
            halt(status);
        }
        //......
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 虚拟机钩子串行化使用

需要注意的虚拟机钩子注册后的调用时机，当JVM执行关闭钩子的时候，如果守护或者非守护线程也在运行，那么虚拟机钩子就可能和这些线程并发的执行，即虚拟机钩子可能会并行的执行一些工作，所以对于一些存在依赖性的共享数据操作，虚拟机钩子要慎重使用。

例如我们用虚拟机钩子将日志服务关闭，此时如果另外的虚拟机钩子需要使用日志打印，可能就会报错：

例如我们的日志框架LogService ，本质上就是对于文件流的写入和关闭：

static class LogService {

        private static final BufferedWriter writer = FileUtil.getWriter("F:\\tmp\\log.txt", Charset.defaultCharset(), true);

        @SneakyThrows
        public void log(String msg) {//将数据写入日志中
            writer.write(msg);
        }


        public void close() {
            try {
                writer.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

如下图所说，若在虚拟机钩子上注册关闭打印和关闭日志框架的钩子，就有可能出现打印钩子抛出stream close的错误：

LogService logService = new LogService();



        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            //抛出stream close的错误
            logService.log("hello world");
        }));

        /**
         * 注册虚拟机钩子
         */
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            //执行一些应用程序的资源关闭
            logService.close();
        }));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

总的来说，使用虚拟机钩子必须注意：

  1. 虚拟机钩子要保证线程安全，即针对共享资源做好同步把控
  2. 虚拟机钩子尽量串行化执行，且钩子之间不可以有任何依赖
  3. 关闭钩子应该尽快的退出，因为它直接的决定的JVM退出的结束时间

# 守护线程

# 守护线程的基本概念

很多人对守护线程都不陌生，对于守护线程大部分读者都停留在JDK官方文档所介绍的概念:

The Java Virtual Machine exits when the only threads running are all daemon threads.

文档的意思是当JVM中不存在任何一个正在运行的非守护线程时，JVM进程会直接退出。

读起来很拗口对不对，没关系，本文就会基于几个代码示例，让你更深层次的理解守护线程。在此之前，读者不妨自测一下，下面这几道面试题：

  1. 守护线程和普通线程有什么区别？
  2. 守护线程默认优先级是多少？
  3. 若父线程为守护线程，在其内部创建一个普通线程，父线程停止，子线程是否也会停止呢？
  4. 如何创建守护线程池？
  5. 守护线程使用有哪些注意事项？

# 守护线程和普通线程的区别

要了解区别就先来了解一下两者的使用，非守护线程，也就我们日常创建的普通线程，可以看到这段代码创建了一个普通线程，在无限循环的定时输出内容，而主线程仅仅是输出一段文字后就不做任何动作了。

public static void main(String[] args) {

        Thread t = new Thread(() -> {
            while (true) {
                log.info("普通线程执行了......");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t.start();
       log.info("主线程运行结束");


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

对应的输出结果如下，可以看到，即使主线程停止运行了，而非守护线程也仍然会在运行，也就是JDK官方文档的字面含义，普通线程不停止，JVM就不停止运行：

12:44:57.022 [Thread-0] INFO com.sharkChili.webTemplate.Main - 普通线程执行了......
12:44:57.022 [main] INFO com.sharkChili.webTemplate.Main - 主线程运行结束
12:45:02.031 [Thread-0] INFO com.sharkChili.webTemplate.Main - 普通线程执行了......
1
2
3

基于上述代码，用setDaemon(true)将该线程设置为守护线程：

public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true) {
                log.info("守护线程执行了......");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        //设置当前线程为守护线程
        t.setDaemon(true);
        t.start();
        log.info("主线程运行结束");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果如下，可以看到随着主线程的消亡，守护线程也会随之停止，不再运行，自此我相信读者可以理解JDK官方文档所说的那句话了，只要有一个普通线程在，JVM就不会退出，只要所有普通线程停止工作，JVM自动退出，守护线程也会自动结束。

12:44:23.239 [Thread-0] INFO com.sharkChili.webTemplate.Main - 守护线程执行了......
12:44:23.239 [main] INFO com.sharkChili.webTemplate.Main - 主线程运行结束
1
2

# 守护线程和普通线程优先级的区别

我们可以通过getPriority方法查看两者的区别：

public static void main(String[] args) {

        Thread t = new Thread(() -> {

            log.info("守护线程优先级:{}", Thread.currentThread().getPriority());
        });

        //设置当前线程为守护线程
        t.setDaemon(true);
        t.start();
        log.info("主线程运行结束,当前线程运行优先级:{}", Thread.currentThread().getPriority());


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

从输出结果来看，两者的优先级是一样的，都为5：

12:54:36.344 [main] INFO com.sharkChili.webTemplate.Main - 主线程运行结束,当前线程运行优先级:5
12:54:36.344 [Thread-0] INFO com.sharkChili.webTemplate.Main - 守护线程优先级:5
1
2

# 父守护线程问题

我们创建了一个守护线程，在其runnable实现中创建一个子线程：


  public static void main(String[] args) {

        Thread parentThread = new Thread(() -> {
            Thread childThread = new Thread(() -> {
                while (true) {
                    log.info("子线程运行中，是否为守护线程:{}",Thread.currentThread().isDaemon());
                    try {
                        TimeUnit.HOURS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            });

            childThread.start();

            log.info("parentThread守护线程运行中");
        });

        //设置当前线程为守护线程
        parentThread.setDaemon(true);
        parentThread.start();
        log.info("主线程运行结束");


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

从输出结果来看，父线程为守护线程时，其内部创建的子线程也为守护线程，所以随着父线程的销毁，子线程也会同步销毁。

00:05:56.869 [Thread-1] INFO com.sharkChili.webTemplate.Main - 子线程运行中，是否为守护线程:true
00:05:56.869 [main] INFO com.sharkChili.webTemplate.Main - 主线程运行结束
00:05:56.869 [Thread-0] INFO com.sharkChili.webTemplate.Main - parentThread守护线程运行中
1
2
3

# 守护线程池的创建

public static void main(String[] args) {

        ExecutorService threadPool = Executors.newFixedThreadPool(10, ThreadFactoryBuilder.create()
                .setNamePrefix("worker-")
                .setDaemon(true)
                .build());
        threadPool.execute(()->{
            while (true){
                try {
                    log.info("守护线程运行了");
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });


        log.info("主线程退出");


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 守护线程的使用场景

因为守护线程拥有自动结束自己生命周期的特性，当JVM中没有一个普通线程运行时，JVM会退出，即所有守护线程会自动停止，所以守护线程的使用场景可以有以下几种：

  1. 垃圾回收线程就是典型的守护线程，在后台进行垃圾对象回收的工作。
  2. 非核心业务工作可交由守护线程，例如:各类信息统计、服务监控等，一旦进程结束运行则这些守护线程停止工作。

# 守护线程注意事项

  1. 复杂计算、资源回收这种不建议使用守护线程。
  2. setDaemon要在start方法前面，否者该设置会不生效。

# finalize关闭的哲学

# finalize函数基本介绍

针对一些系统资源例如文件句柄或者套接字句柄，当不需要它们时，垃圾回收器定义了finalize方法进行一些资源关闭，一旦垃圾回收器回收这些对象之后，对应的资源就会调用finalize释放。

例如FileInputStream的finalize方法，它就会检查当前文件句柄是否非空，然后显示的调用一下close方法：

 protected void finalize() throws IOException {
        if ((fd != null) &&  (fd != FileDescriptor.in)) {
          	//关闭文件句柄
            close();
        }
    }
1
2
3
4
5
6

# finalize使用最佳实践

需要注意的finalize在JVM运行中可能会执行也可能不会执行，JVM对此无法做出保证，所以它运行时存着极端的不确定性，所以进行资源关闭时，我们非常不建议使用finalize。

正确的一些系统资源关闭回收，笔者更建议是使用阶段采用try-with-resource手动关闭资源：

//使用try-with-resource手动关闭资源
try(BufferedReader reader = FileUtil.getUtf8Reader("filePahth")){
            System.out.println(reader.readLine());
        }catch (Exception e){
            //异常处理
        }
1
2
3
4
5
6

# 小结

本文我们的虚拟机钩子、守护线程、finalize三个角度针对java程序优雅关闭的哲学进行一些实践演示和建议，希望对你有帮助。

我是 SharkChili ，Java 开发者，Java Guide 开源项目维护者。欢迎关注我的公众号：写代码的SharkChili，也欢迎您了解我的开源项目 mini-redis：https://github.com/shark-ctrl/mini-redis (opens new window)。

为方便与读者交流，现已创建读者群。关注上方公众号获取我的联系方式，添加时备注加群即可加入。

# 参考

Java 多线程之守护 (Daemon) 线程:https://blog.csdn.net/qq_33479841/article/details/121950775 (opens new window)

JAVA多线程基础篇--守护线程(Daemon Thread):https://www.exception.site/java-concurrency/java-concurrency-daemon-thread (opens new window)

《Java并发编程实战》

编辑 (opens new window)
上次更新: 2026/03/26, 01:05:31
浅谈池化技术的优雅关闭
浅谈并发编程等待通知模型

← 浅谈并发编程等待通知模型→

最近更新
01
基于EasyExcel实现高效导出
03-25
02
从开源框架中学习那些实用的位运算技巧
03-25
03
浅谈分布式架构设计思想和常见优化手段
03-25
更多文章>
Theme by Vdoing | Copyright © 2025-2026 Evan Xu | MIT License | 桂ICP备2024034950号 | 桂公网安备45142202000030
×
×