JVM关闭钩子（2）—— 源码浅析

最新推荐文章于 2023-12-26 17:26:58 发布

Jacky-止涯

最新推荐文章于 2023-12-26 17:26:58 发布

阅读量3.4k

点赞数

CC 4.0 BY-SA版权

分类专栏： JDK 源码 Java相关文章标签：关闭钩子源代码 jdk Shutdown ShutdownHooks

本文链接：https://blog.youkuaiyun.com/tiwerbao/article/details/8933157

Java相关同时被 2 个专栏收录

31 篇文章

订阅专栏

JDK 源码

15 篇文章

订阅专栏

本文详细介绍了Java中关闭钩子的实现原理，包括Shutdown类的状态管理与钩子执行流程，以及ApplicationShutdownHooks如何维护用户级别的关闭钩子。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

上一篇《JVM关闭钩子（1）—— 概念和应用》简单解释了什么是钩子，并且举例说明了Java中关闭钩子的使用，现在我们来深入了解，Java中怎么实现这个关闭钩子的。

主要通过java.lang.Shutdown和java.lang.ApplicationShutdownHooks 这两个工具类来实现。Shutdown负责触发钩子，而ApplicationShutdownHooks负责维护钩子。【此处只介绍用户等级的关闭钩子】

java.lang.Shutdown

Java中的Shutdown类，是一个包私有的工作类，用于顺序关闭JVM，并触发关闭钩子。

Shutdown中定义了三个状态，用于校验关闭时机。初始是运行状态RUNNING。

    private static final int RUNNING = 0;
    private static final int HOOKS = 1;
    private static final int FINALIZERS = 2;
    private static int state = RUNNING;

Shutdown初始定义了一个Runnable数组hooks，其中每个元素代表一个关闭钩子类型，一般我们应用程序添加的，都为应用类型(1)，在下面介绍ApplicationShutdownHooks会提到。

    // (0)Console restore hook
    // (1)Application hooks
    // (2)DeleteOnExit hook
    private static final int MAX_SYSTEM_HOOKS = 10;
    private static final Runnable[] hooks = new Runnable[MAX_SYSTEM_HOOKS];

添加钩子

每种类型的钩子只能添加一次，否则会抛出异常，且每次添加的时候都需要校验当前状态。

static void add(int slot, booleanregisterShutdownInProgress, Runnable hook) {
        synchronized (lock) {
            if (hooks[slot] != null)       // 保证每个种类的钩子不会重复初始化
                throw new InternalError("hookat slot "+slot+" already registered");
 
// 初始状态检查
            if (!registerShutdownInProgress)
                if (state > RUNNING)
                    throw new IllegalStateException("Shutdown in progress");
            else
                if (state > HOOKS || (state == HOOKS&& slot <= currentRunningHook))
                    throw new IllegalStateException("Shutdown in progress");
 
            hooks[slot] = hook;
        }
}

执行钩子

执行关闭钩子，是在JVM的关闭事件触发之后。通常是下面两种情况：

A Runtime.exit()，这时候会调用Shutdown.exit()；

B JNI来DestroyJVM，这时候会调用Shutdown.shutdown()；

这两个方法，最后都会调用Shutdown.sequence()来触发关闭钩子和停止JVM。

private static void sequence() {
        synchronized (lock) {
            if (state != HOOKS) return;
        }
        runHooks();          // 执行关闭钩子
        boolean rfoe;
        synchronized (lock) {
            state = FINALIZERS;
            rfoe = runFinalizersOnExit;
        }
        if (rfoe) runAllFinalizers();         // 全面停止系统
}

执行关闭钩子，遍历hooks，把所有类型的钩子都run()起来。

private static void runHooks() {
        for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {
            try {
                Runnable hook;
                synchronized (lock) {
                    currentRunningHook = i;
                    hook = hooks[i];
                }
                if (hook != null) hook.run();
            } catch(Throwable t) {}
        }
}

java.lang.ApplicationShutdownHooks

用户等级的关闭钩子由ApplicationShutdownHooks来存放和维护。

在ApplicationShutdownHooks中，通过一个Map属性hooks来保存用户的关闭钩子。实际上每个关闭钩子都是一个线程，当JVM关闭事件触发的时候，就会执行钩子逻辑。

private staticIdentityHashMap<Thread, Thread> hooks;

这里使用IdentityHashMap来储存，这个map的key只比较地址，确保钩子的唯一性。即使两个对象属性完全一样，这里也会当成两个hook来处理。这个IdentityHashMap的具体实现，可以参考我的《JDK-Map源码浅析——IdentityHashMap 》。

初始化，添加钩子类型

在ApplicationShutdownHooks加载的时候，首先会往Shutdown中add一个应用类型(1)的钩子类型线程，然后把执行钩子逻辑的runHooks() 放入run()中等待调用。

这里ApplicationShutdownHooks为什么不实现Runnable接口，然后直接把自己add到Shutdown中呢？因为没有必要：

因为Shutdown只关心用户的钩子，而对维护者ApplicationShutdownHooks没有兴趣，基于安全或者使用来考虑，都没有必要把ApplicationShutdownHooks整个传进去。所以这里新建一个线程，只把 runHooks()的调用放进去，足矣。

这样一来，ApplicationShutdownHooks就不用实例化，可以做成单例，彻底变成了一个工具类，只用适度地暴露一些工具方法即可，并且通过静态属性hooks来保存钩子。

让ApplicationShutdownHooks和钩子类型线程分离，使职能独立化简单化。

 static {
        try {
            Shutdown.add(1, false,
                new Runnable() {
                    public void run() {
                        runHooks();
                    }
                }
            );
            hooks = new IdentityHashMap<>();
        } catch (IllegalStateException e) {
            hooks = null;
        }
    }
    private ApplicationShutdownHooks() {}

添加/删除钩子，需要进行一些有效校验。

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

运行钩子

运行钩子方法runHooks()，提供给钩子类型线程调用。

定义一个局部Thread来转移hooks，转移后清空hooks。能看出来，关闭钩子逻辑只会执行一次，执行后就清空了，因为JVM关闭才会触发。另外，转移和清空也有利于避免并发的冲突。

接着启动这些钩子线程，而且通过join来保证线程的同步执行。(此处恰到好处地把start和join分开写，下面讨论这样写的好处)

static void runHooks() {
        Collection<Thread> 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) { }
        }
    }

—— 源码来自于 JDK1.7

此处给大家留两个问题，大伙可以留言交流交流想法和心得