ShutdownHook 介绍

在 java 程序中，很容易在进程结束时添加一个钩子，即ShutdownHook。通常在程序启动时加入以下代码即可

Runtime.getRuntime().addShutdownHook(new Thread(){    @Override    public void run() {        System.out.println("I'm shutdown hook...");    }});

有了 ShutdownHook 我们可以

• 在进程结束时做一些善后工作，例如释放占用的资源，保存程序状态等

• 为优雅（平滑）发布提供手段，在程序关闭前摘除流量

不少 java 中间件或框架都使用了 ShutdownHook 的能力，如 dubbo、spring 等。

spring 中在 application context 被 load 时会注册一个 ShutdownHook。这个 ShutdownHook 会在进程退出前执行销毁 bean，发出 ContextClosedEvent 等动作。而 dubbo 在 spring 框架下正是监听了 ContextClosedEvent，调用dubboBootstrap.stop()来实现清理现场和 dubbo 的优雅发布，spring 的事件机制默认是同步的，所以能在 publish 事件时等待所有监听者执行完毕。

ShutdownHook 原理

ShutdownHook 的数据结构与执行顺序

• 当我们添加一个 ShutdownHook 时，会调用ApplicationShutdownHooks.add(hook)，往ApplicationShutdownHooks类下的静态变量private static IdentityHashMap<Thread, Thread> hooks添加一个 hook，hook 本身是一个 thread 对象

• ApplicationShutdownHooks类初始化时会把hooks添加到Shutdown的hooks中去，而Shutdown的hooks是系统级的 ShutdownHook，并且系统级的 ShutdownHook 由一个数组构成，只能添加 10 个

• 系统级的 ShutdownHook 调用了 thread 类的run方法，所以系统级的 ShutdownHook 是同步有序执行的

private static void runHooks() {    for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {        try {            Runnable hook;            synchronized (lock) {                // acquire the lock to make sure the hook registered during                // shutdown is visible here.                currentRunningHook = i;                hook = hooks[i];            }            if (hook != null) hook.run();        } catch(Throwable t) {            if (t instanceof ThreadDeath) {                ThreadDeath td = (ThreadDeath)t;                throw td;            }        }    }}

• 系统级的 ShutdownHook 的add方法是包可见，即我们不能直接调用它

• ApplicationShutdownHooks位于下标1处，且应用级的 hooks，执行时调用的是 thread 类的start方法，所以应用级的 ShutdownHook 是异步执行的，但会等所有 hook 执行完毕才会退出。

static void runHooks() {    Collection<Thread> threads;    synchronized(ApplicationShutdownHooks.class) {        threads = hooks.keySet();        hooks = null;    }
    for (Thread hook : threads) {        hook.start();    }    for (Thread hook : threads) {        while (true) {            try {                hook.join();                break;            } catch (InterruptedException ignored) {            }        }    }}

用一副图总结如下：

ShutdownHook 触发点

从Shutdown的runHooks顺藤摸瓜，我们得出以下这个调用路径

重点看Shutdown.exit 和 Shutdown.shutdown

Shutdown.exit

跟进Shutdown.exit的调用方，发现有 Runtime.exit 和 Terminator.setup

• Runtime.exit 是代码中主动结束进程的接口

• Terminator.setup 被 initializeSystemClass 调用，当第一个线程被初始化的时候被触发，触发后注册了一个信号监控函数，捕获kill发出的信号，调用Shutdown.exit结束进程

这样覆盖了代码中主动结束进程和被kill杀死进程的场景。

主动结束进程不必介绍，这里说一下信号捕获。在 java 中我们可以写出如下代码来捕获 kill 信号，只需要实现SignalHandler接口以及handle方法，程序入口处注册要监听的相应信号即可，当然不是每个信号都能捕获处理。

public class SignalHandlerTest implements SignalHandler {
    public static void main(String[] args) {
        Runtime.getRuntime().addShutdownHook(new Thread() {            @Override            public void run() {                System.out.println("I'm shutdown hook ");            }        });
        SignalHandler sh = new SignalHandlerTest();        Signal.handle(new Signal("HUP"), sh);        Signal.handle(new Signal("INT"), sh);        //Signal.handle(new Signal("QUIT"), sh);// 该信号不能捕获        Signal.handle(new Signal("ABRT"), sh);        //Signal.handle(new Signal("KILL"), sh);// 该信号不能捕获        Signal.handle(new Signal("ALRM"), sh);        Signal.handle(new Signal("TERM"), sh);
        while (true) {            System.out.println("main running");            try {                Thread.sleep(2000L);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }
    @Override    public void handle(Signal signal) {        System.out.println("receive signal " + signal.getName() + "-" + signal.getNumber());        System.exit(0);    }}

要注意的是通常来说，我们捕获信号，做了一些个性化的处理后需要主动调用System.exit，否则进程就不会退出了，这时只能使用kill -9来强制杀死进程了。

而且每次信号的捕获是在不同的线程中，所以他们之间的执行是异步的。

Shutdown.shutdown

这个方法可以看注释

/* Invoked by the JNI DestroyJavaVM procedure when the last non-daemon
  * thread has finished.  Unlike the exit method, this method does not
  * actually halt the VM.
  */

翻译一下就是该方法会在最后一个非daemon线程（非守护线程）结束时被 JNI 的DestroyJavaVM方法调用。

java 中有两类线程，用户线程和守护线程，守护线程是服务于用户线程，如 GC 线程，JVM 判断是否结束的标志就是是否还有用户线程在工作。当最后一个用户线程结束时，就会调用 Shutdown.shutdown。这是 JVM 这类虚拟机语言特有的"权利"，倘若是 golang 这类编译成可执行的二进制文件时，当全部用户线程结束时是不会执行ShutdownHook的。

举个例子，当 java 进程正常退出时，没有在代码中主动结束进程，也没有kill，就像这样

public static void main(String[] args) {
    Runtime.getRuntime().addShutdownHook(new Thread() {        @Override        public void run() {            super.run();            System.out.println("I'm shutdown hook ");        }    });}

当 main 线程运行完了后，也能打印出I'm shutdown hook，反观 golang 就做不到这一点（如果可以做到，可以私信告诉我，我是个 golang 新手）

通过如上两个调用的分析，我们概括出如下结论：

我们能看出 java 的 ShutdownHook 其实覆盖的非常全面了，只有一处无法覆盖，即当我们杀死进程时使用了kill -9时，由于程序无法捕获处理，进程被直接杀死，所以无法执行ShutdownHook。

总结

综上，我们得出一些结论

• 重写捕获信号需要注意主动退出进程，否则进程可能永远不会退出，捕获信号的执行是异步的

• 用户级的 ShutdownHook 是绑定在系统级的 ShutdownHook 之上，且用户级是异步执行，系统级是同步顺序执行，用户级处于系统级执行顺序的第二位

• ShutdownHook 覆盖的面比较广，不论是手动调用接口退出进程，还是捕获信号退出进程，抑或是用户线程执行完毕退出，都会执行 ShutdownHook，唯一不会执行的就是 kill -9

搜索关注公众号“捉虫大师”，给你推送朴实无华且枯燥的技术文章[狗头]