Java关闭钩子

背景

在JVM退出时，我们有时候希望系统帮忙完成一些清场工作，例如状态同步，系统资源释放等等。JAVA中的ShutdownHook提供了比较好的方案。

什么时shutdownHook？

Shutdown hook是一个initialized but unstarted thread。当JVM开始执行shutdown sequence时，会并发运行所有registered Shutdown Hook。这时，在Shutdown Hook这个线程里定义的操作便会开始执行。需要注意的是，在Shutdown Hook里执行的操作应当是不太耗时的。因为在用户注销或者操作系统关机导致的JVM shutdown的例子中，系统只会预留有限的时间给未完成的工作，超时之后还是会强制关闭。

JDK提供了Java.Runtime.addShutdownHook(Thread hook)方法，可以注册一个JVM关闭的钩子，这个钩子可以在一下几种场景中被调用：

1. 程序正常退出
2. 使用System.exit()
3. 终端使用Ctrl+C触发的中断
4. 系统关闭
5. OutOfMemory宕机
6. 使用Kill pid命令干掉进程（注：在使用kill -9 pid时，是不会被调用的

如何使用Shutdown Hook

调用java.lang.Runtime这个类的addShutdownHook(Thread hook)方法即可注册一个Shutdown Hook，然后在Thread中定义需要在system exit时进行的操作。如下：

Runtime.getRuntime().addShutdownHook(new Thread(() -> System.out.println("Do something in Shutdown Hook")));
实例代码如下：

package com.demo;

public class ShutdownHookTest {

    public static void main(String[] args) {
        Thread hook = new Thread(new Hook("A"));
        Runtime.getRuntime().addShutdownHook(hook);
        hook = new Thread(new Hook("B"));
        Runtime.getRuntime().addShutdownHook(hook);
        hook = new Thread(new Hook("C"));
        Runtime.getRuntime().addShutdownHook(hook);
        hook = new Thread(new Hook("D"));
        Runtime.getRuntime().addShutdownHook(hook);
        int count = 0;
        while (count < 10) {
            new Thread(new NomalThread()).start();
            count++;
        }
    }
}

class Hook implements Runnable {

    private String hookName;

    public Hook(String hookName) {
        super();
        this.hookName = hookName;
    }

    @Override
    public void run() {
        System.out.println("i am the shutdown hook[" + hookName + "]");
    }

}

class NomalThread implements Runnable {

    @Override
    public void run() {
        System.out.println(String.format("Thread %s running", Thread.currentThread().getName()));
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

源码解读

//java.lang.Runtime
public void addShutdownHook(Thread hook) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new RuntimePermission("shutdownHooks"));
        }
        ApplicationShutdownHooks.add(hook);
    }

//java.lang.ApplicationShutdownHooks
/* Add a new shutdown hook.  Checks the shutdown state and the hook itself,
     * but does not do any security checks.
     */
    static synchronized void add(Thread hook) {
        if(hooks == null)
            throw new IllegalStateException("Shutdown in progress");

        if (hook.isAlive())
            throw new IllegalArgumentException("Hook already running");

        if (hooks.containsKey(hook))
            throw new IllegalArgumentException("Hook previously registered");

        hooks.put(hook, hook);
    }

//hooks有什么用？
/* Iterates over all application hooks creating a new thread for each
     * to run in. Hooks are run concurrently and this method waits for
     * them to finish.
     */
    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) {
                }
            }
        }
    }


/*
这些钩子会在ApplicationShutdownHooks的初始化的时候，在static块里面被添加到Shudown的hooks里面
java.lang.ApplicationShutdownHooks
*/
static {
        try {
            Shutdown.add(1 /* shutdown hook invocation order */,
                false /* not registered if shutdown in progress */,
                new Runnable() {
                    public void run() {
                        runHooks();
                    }
                }
            );
            hooks = new IdentityHashMap<>();
        } catch (IllegalStateException e) {
            // application shutdown hooks cannot be added if
            // shutdown is in progress.
            hooks = null;
        }
    }
// 注意，Shutdown的hooks和ApplicationShutdownHooks.hooks不同
//添加到Shutdown的hooks
/**
     * Add a new system shutdown hook.  Checks the shutdown state and
     * the hook itself, but does not do any security checks.
     *
     * The registerShutdownInProgress parameter should be false except
     * registering the DeleteOnExitHook since the first file may
     * be added to the delete on exit list by the application shutdown
     * hooks.
     *
     * @params slot  the slot in the shutdown hook array, whose element
     *               will be invoked in order during shutdown
     * @params registerShutdownInProgress true to allow the hook
     *               to be registered even if the shutdown is in progress.
     * @params hook  the hook to be registered
     *
     * @throws IllegalStateException
     *         if registerShutdownInProgress is false and shutdown is in progress; or
     *         if registerShutdownInProgress is true and the shutdown process
     *         already passes the given slot
     */
    static void add(int slot, boolean registerShutdownInProgress, Runnable hook) {
        if (slot < 0 || slot >= MAX_SYSTEM_HOOKS) {
            throw new IllegalArgumentException("Invalid slot: " + slot);
        }
        synchronized (lock) {
            if (hooks[slot] != null)
                throw new InternalError("Shutdown hook at slot " + slot + " already registered");

            if (!registerShutdownInProgress) {
                if (currentRunningHook >= 0)
                    throw new IllegalStateException("Shutdown in progress");
            } else {
                if (VM.isShutdown() || slot <= currentRunningHook)
                    throw new IllegalStateException("Shutdown in progress");
            }

            hooks[slot] = hook;
        }
    }

//执行真正的shutdown钩子
/* Run all system shutdown hooks.
     *
     * The system shutdown hooks are run in the thread synchronized on
     * Shutdown.class.  Other threads calling Runtime::exit, Runtime::halt
     * or JNI DestroyJavaVM will block indefinitely.
     *
     * ApplicationShutdownHooks is registered as one single hook that starts
     * all application shutdown hooks and waits until they finish.
     */
    private static void runHooks() {
        synchronized (lock) {
            /* Guard against the possibility of a daemon thread invoking exit
             * after DestroyJavaVM initiates the shutdown sequence
             */
            if (VM.isShutdown()) return;
        }

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

        // set shutdown state
        VM.shutdown();
    }



//这个Shutdown.runHooks何时执行？
/* Invoked by Runtime.exit, which does all the security checks.
     * Also invoked by handlers for system-provided termination events,
     * which should pass a nonzero status code.
     */
    static void exit(int status) {
        synchronized (lock) {
            if (status != 0 && VM.isShutdown()) {
                /* Halt immediately on nonzero status */
                halt(status);
            }
        }
        synchronized (Shutdown.class) {
            /* Synchronize on the class object, causing any other thread
             * that attempts to initiate shutdown to stall indefinitely
             */
            beforeHalt();
            runHooks();
            halt(status);
        }
    }


    /* 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.
     */
    static void shutdown() {
        synchronized (Shutdown.class) {
            runHooks();
        }
    }

//再进一步，这个exit/shutdown方法什么时候执行
//exit方法再往上层追溯找到了我门熟悉的System.exit方法，shutdown暂时没找到调用之处

//由此可见在执行System.exit方法之前会执行hooks里面所有的钩子

shutdownHook应用场景

很多时候，我们会有这样的一些场景，比如说nginx反向代理若干个负载均衡的web容器，又或者微服务架构中存在的若干个服务节点，需要进行无间断的升级发布。
在重启服务的时候，除非我们去变更nginx的配置，否则重启很可能会导致正在执行的线程突然中断，本来应该要完成的事情只完成了一半，并且调用方出现错误警告。
如果能有一种简单的方式，能够让进程在退出时能执行完当前正在执行的任务，并且让服务的调用方将新的请求定向到其他负载节点，这将会很有意义。
自己注册ShutdownHook可以帮助我们实现java进程的平滑退出。
设计思路：

1. 在服务启动时注册自己的ShutdownHook
2. ShutdownHook在被运行时，首先不接收新的请求，或者告诉调用方重定向到其他节点
3. 等待当前的执行线程运行完毕，如果指定时间后仍在运行，则强制退出