Java ShutDown Hook介绍和使用

概述：

之前有了解过Java的ShutDown Hook机制，但是因为没有使用场景也没有深入学习，最近刚好又看到ShutDown Hook的一些东西，想着学习总结一下，做下学习记录。Java的Shutdown Hook是一种机制，允许开发者在Java虚拟机（JVM）即将关闭之前执行一些清理或终止操作。Shutdown Hook提供了一个钩子，允许开发者在JVM关闭时捕获到关闭事件并执行相应的逻辑。以下是一些使用场景：

1. 资源释放和清理：当应用程序结束或JVM关闭时，可以使用Shutdown Hook来释放和清理打开的文件、网络连接、数据库连接等资源。这确保资源在程序终止之前得到适当的关闭，避免资源泄露和数据丢失。
2. 日志记录和统计：Shutdown Hook可以用于记录应用程序的关键统计信息或生成最终的日志报告。通过在JVM关闭前执行这些操作，可以捕获应用程序在运行期间的关键数据，并生成相应的日志记录。
3. 缓存刷新：如果应用程序使用了缓存机制，可以在JVM关闭前使用Shutdown Hook来刷新缓存，将缓存中的数据写回到持久化存储或其他目标中，确保数据的持久化和一致性。
4. 任务终止和状态保存：在某些情况下，可能需要在应用程序终止时保存任务的当前状态，以便在下次启动时恢复。通过在Shutdown Hook中执行任务的状态保存操作，可以将任务的状态保存到持久化存储中，并在下次启动时进行恢复。
5. 线程管理：Shutdown Hook还可以用于管理和终止应用程序中的线程。在JVM关闭前，可以使用Shutdown Hook发送终止信号给正在运行的线程，以确保它们在终止之前完成当前任务并进行清理操作。

上面说的这些使用场景，我都没用到过，大家可以先了解一下对ShutDownHook有一个简单的认识。

分析：

下面我们从源码上去看一下，ShutDown Hook的方法和原理。

跟它相关的主要有两个类ApplicationShutdownHooks和Runtime

class ApplicationShutdownHooks {
    /* The set of registered hooks */
    private static IdentityHashMap hooks;
    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;
        }
    }


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

    /* Remove a previously-registered hook.  Like the add method, this method
     * does not do any security checks.
     */
    static synchronized boolean remove(Thread hook) {
        if(hooks == null)
            throw new IllegalStateException("Shutdown in progress");

        if (hook == null)
            throw new NullPointerException();

        return hooks.remove(hook) != null;
    }

    /* 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 threads;
        synchronized(ApplicationShutdownHooks.class) {
            threads = hooks.keySet();
            hooks = null;
        }

        for (Thread hook : threads) {
            hook.start();
        }
        for (Thread hook : threads) {
            try {
                hook.join();
            } catch (InterruptedException x) { }
        }
    }
}

 -- Runtime.class里面的方法
 public void addShutdownHook(Thread hook) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new RuntimePermission("shutdownHooks"));
        }
        ApplicationShutdownHooks.add(hook);
    }

    public boolean removeShutdownHook(Thread hook) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new RuntimePermission("shutdownHooks"));
        }
        return ApplicationShutdownHooks.remove(hook);
    }


    public void halt(int status) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkExit(status);
        }
        Shutdown.halt(status);
    }

结合这两个类的源码，我们可以看到添加Hook其实是往ApplicationShutdownHooks的静态Map里面放入新的线程，但是这些线程只是创建后被保存了起来，只有当程序退出时，runHooks被执行，每一个带有Hook任务的线程才的start()方法才被执行，也因为Hook之间是相互独立的线程，所以它们之间执行是没有顺序的，而且因为主线程调用了每个Hook的线程的join方法，所以主线程会等待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");

1.ApplicationShutdownHooks已经在调用Hook时，hooks会置为null，不能在添加hook

2.Hook的Thread不能是已经在运行状态的线程

3.因为储存的Hook是根据线程是否相同来判断的，所以同样的Hook无法被添加

不适用的情况：

1.因为ShutDown Hook只能处理正常退出的情况，kill -9这种是无法处理的

2Shutdown.halt和kill -9一样都是强制退出，不会给Hook执行的机会

使用：

下面放了一些简单的测试ShutDown的小例子，github地址：

 @Test
    public void test1() {
        // 测试正常退出的情况
        Runtime.getRuntime().addShutdownHook(
                new Thread(
                        () -> {
                            System.out.println("hook1 执行了");
                        })
        );
    }
    
    输出：hook1 执行了

 @Test
    public void test2() {
        // 测试Hook执行顺序是否真的无序
        Runtime.getRuntime().addShutdownHook(
                new Thread(
                        () -> {
                            System.out.println("hook1 执行了");
                        })
        );

        Runtime.getRuntime().addShutdownHook(
                new Thread(
                        () -> {
                            System.out.println("hook2 执行了");
                        })
        );
    }
    
    输出：输出结果hook1和hook2会随机打印，没有固定顺序

 @Test
    public void test3() {
        // 测试kill -9 会执行Hook吗
        Runtime.getRuntime().addShutdownHook(
                new Thread(
                        () -> {
                            System.out.println("hook1 执行了");
                        })
        );

        while(true) {

        }

    }
    
    输出：

    @Test
    public void test4() {
        // 测试oom时 会执行Hook吗
        Runtime.getRuntime().addShutdownHook(
                new Thread(
                        () -> {
                            System.out.println("hook1 执行了");
                        })
        );

   
        List