Java优雅关服

---

前言

java中的Runtime.addShutdownHook()可以添加钩子函数在接收到程序关闭信号的时候进行一些线程关闭资源回收的工作，也是一般实现优雅关服的基础。我们来扒一扒这个shutdownHook的实现过程。

一、钩子的添加和调用流程

1.Runtime#addShutdownHook

首先看看jdk对Runtime#addShutdownHook的说明。

/**
 * Registers a new virtual-machine shutdown hook.
 *
 * <p> The Java virtual machine <i>shuts down</i> in response to two kinds
 * of events:
 *
 *   <ul>
 *
 *   <li> The program <i>exits</i> normally, when the last non-daemon
 *   thread exits or when the <tt>{@link #exit exit}</tt> (equivalently,
 *   {@link System#exit(int) System.exit}) method is invoked, or
 *
 *   <li> The virtual machine is <i>terminated</i> in response to a
 *   user interrupt, such as typing <tt>^C</tt>, or a system-wide event,
 *   such as user logoff or system shutdown.
 *
 *   </ul>
 *
 * <p> A <i>shutdown hook</i> is simply an initialized but unstarted
 * thread.  When the virtual machine begins its shutdown sequence it will
 * start all registered shutdown hooks in some unspecified order and let
 * them run concurrently.  When all the hooks have finished it will then
 * run all uninvoked finalizers if finalization-on-exit has been enabled.
 * Finally, the virtual machine will halt.  Note that daemon threads will
 * continue to run during the shutdown sequence, as will non-daemon threads
 * if shutdown was initiated by invoking the <tt>{@link #exit exit}</tt>
 * method.
 *
 * <p> Once the shutdown sequence has begun it can be stopped only by
 * invoking the <tt>{@link #halt halt}</tt> method, which forcibly
 * terminates the virtual machine.
 *
 * <p> Once the shutdown sequence has begun it is impossible to register a
 * new shutdown hook or de-register a previously-registered hook.
 * Attempting either of these operations will cause an
 * <tt>{@link IllegalStateException}</tt> to be thrown.
 *
 * <p> Shutdown hooks run at a delicate time in the life cycle of a virtual
 * machine and should therefore be coded defensively.  They should, in
 * particular, be written to be thread-safe and to avoid deadlocks insofar
 * as possible.  They should also not rely blindly upon services that may
 * have registered their own shutdown hooks and therefore may themselves in
 * the process of shutting down.  Attempts to use other thread-based
 * services such as the AWT event-dispatch thread, for example, may lead to
 * deadlocks.
 *
 * <p> Shutdown hooks should also finish their work quickly.  When a
 * program invokes <tt>{@link #exit exit}</tt> the expectation is
 * that the virtual machine will promptly shut down and exit.  When the
 * virtual machine is terminated due to user logoff or system shutdown the
 * underlying operating system may only allow a fixed amount of time in
 * which to shut down and exit.  It is therefore inadvisable to attempt any
 * user interaction or to perform a long-running computation in a shutdown
 * hook.
 *
 * <p> Uncaught exceptions are handled in shutdown hooks just as in any
 * other thread, by invoking the <tt>{@link ThreadGroup#uncaughtException
 * uncaughtException}</tt> method of the thread's <tt>{@link
 * ThreadGroup}</tt> object.  The default implementation of this method
 * prints the exception's stack trace to <tt>{@link System#err}</tt> and
 * terminates the thread; it does not cause the virtual machine to exit or
 * halt.
 *
 * <p> In rare circumstances the virtual machine may <i>abort</i>, that is,
 * stop running without shutting down cleanly.  This occurs when the
 * virtual machine is terminated externally, for example with the
 * <tt>SIGKILL</tt> signal on Unix or the <tt>TerminateProcess</tt> call on
 * Microsoft Windows.  The virtual machine may also abort if a native
 * method goes awry by, for example, corrupting internal data structures or
 * attempting to access nonexistent memory.  If the virtual machine aborts
 * then no guarantee can be made about whether or not any shutdown hooks
 * will be run. <p>
 *
 * @param   hook
 *          An initialized but unstarted <tt>{@link Thread}</tt> object
 *
 * @throws  IllegalArgumentException
 *          If the specified hook has already been registered,
 *          or if it can be determined that the hook is already running or
 *          has already been run
 *
 * @throws  IllegalStateException
 *          If the virtual machine is already in the process
 *          of shutting down
 *
 * @throws  SecurityException
 *          If a security manager is present and it denies
 *          <tt>{@link RuntimePermission}("shutdownHooks")</tt>
 *
 * @see #removeShutdownHook
 * @see #halt(int)
 * @see #exit(int)
 * @since 1.3
 */
 public void addShutdownHook(Thread hook) {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        sm.checkPermission(new RuntimePermission("shutdownHooks"));
    }
    ApplicationShutdownHooks.add(hook);
}

主要就是说明了这是个注册钩子的方法，这个钩子会对两类事件响应

1. 一个是程序正常关闭，最后一个守护线程关闭或者Runtime.exit方法被调用。
2. 一个是用户的中断操作如ctrl-c(linux会向进程发送2-INT信号)和系统关机(linux会向进程发送15-TERM信号)。

以及一些使用的注意事项，避免线程不安全导致的死锁，钩子里的处理工作应尽快完成，在平台上发送一些特定的信号如unix平台上发送SIGKILL(kill 9)信号和widown平台上的TerminateProcess会导致钩子不能正常执行。

2.ApplicationShutdownHooks#add

在ApplicationShutdownHooks里可以看到钩子被添加到静态变量hooks中了，hooks被runHooks方法调用，runHooks方法在ApplicationShutdownHooks类初始化的时候作为runable执行逻辑被Shutdown#add添加了。从runHooks方法调用钩子的方式咱们可以看到钩子是并发运行而不是串行的，所以添加钩子的时候要注意不能有顺序依赖。

/*
 * Class to track and run user level shutdown hooks registered through
 * <tt>{@link Runtime#addShutdownHook Runtime.addShutdownHook}</tt>.
 *
 * @see java.lang.Runtime#addShutdownHook
 * @see java.lang.Runtime#removeShutdownHook
 */

class ApplicationShutdownHooks {
    /* The set of registered hooks */
    private static IdentityHashMap<Thread, Thread> 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;
        }
    }
    
    /* 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) {
            try {
                hook.join();
            } catch (InterruptedException x) { }
        }
    }
    
    /* 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);
    }    

咱们接着看看Shutdown类是怎么使用这个runable的

3.Shutdown#add

可以看到Shutdown#add()方法也是类似ApplicationShutdownHooks把钩子添加到hooks数组中并由runHooks方法调用，两个类的操作很类似，但是一个(ApplicationShutdownHooks)是用户级的钩子一个(Shutdown)是系统级的，并且看上面ApplicationShutdownHooks调用Shutdown#add的索引参数为什么是1，这个疑问可以在下方的11-15行得到解释。另外的0和2索引通过System#registerShutdownHook分别在Console类和DeleteOnExitHook类使用。

/**
 * Package-private utility class containing data structures and logic
 * governing the virtual-machine shutdown sequence.
 *
 * @author   Mark Reinhold
 * @since    1.3
 */

class Shutdown {

    // The system shutdown hooks are registered with a predefined slot.
    // The list of shutdown hooks is as follows:
    // (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];

    /**
     * Add a new 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
     *
     * @throw 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) {
        synchronized (lock) {
            if (hooks[slot] != null)
                throw new InternalError("Shutdown hook at 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;
        }
    }

    /* Run all registered shutdown hooks
     */
    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;
                }
            }
        }
    }

}

4.Shutdown#sequence

Shutdown类中添加到hooks的钩子在sequence方法中通过调用runHooks方法执行钩子，sequence方法被exit()和shutdown()方法调用，shutdown方法由JNI(Java Native Interface)调用，exit()方法带有一个status参数，用来判断是否调用runAllFinalizers执行一些清理工作，正常退出程序都应该传0，从Runtime#exit方法头的注释也可以佐证这一点。当status不为0的时候runAllFinalizers不会得到执行。

这里有个疑问，从各方面信息来看Shutdown#exit的status参数是否为0表示程序是否正常退出为什么在Terminator#setup中信号注册处理器的时候，Shutdown#exit的status参数是非0？

/* The actual shutdown sequence is defined here.
 *
 * If it weren't for runFinalizersOnExit, this would be simple -- we'd just
 * run the hooks and then halt.  Instead we need to keep track of whether
 * we're running hooks or finalizers.  In the latter case a finalizer could
 * invoke exit(1) to cause immediate termination, while in the former case
 * any further invocations of exit(n), for any n, simply stall.  Note that
 * if on-exit finalizers are enabled they're run iff the shutdown is
 * initiated by an exit(0); they're never run on exit(n) for n != 0 or in
 * response to SIGINT, SIGTERM, etc.
 */
private static void sequence() {
    synchronized (lock) {
        /* Guard against the possibility of a daemon thread invoking exit
         * after DestroyJavaVM initiates the shutdown sequence
         */
        if (state != HOOKS) return;
    }
    runHooks();
    boolean rfoe;
    synchronized (lock) {
        state = FINALIZERS;
        rfoe = runFinalizersOnExit;
    }
    if (rfoe) runAllFinalizers();
}


/* 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) {
    boolean runMoreFinalizers = false;
    synchronized (lock) {
        if (status != 0) runFinalizersOnExit = false;
        switch (state) {
        case RUNNING:       /* Initiate shutdown */
            state = HOOKS;
            break;
        case HOOKS:         /* Stall and halt */
            break;
        case FINALIZERS:
            if (status != 0) {
                /* Halt immediately on nonzero status */
                halt(status);
            } else {
                /* Compatibility with old behavior:
                 * Run more finalizers and then halt
                 */
                runMoreFinalizers = runFinalizersOnExit;
            }
            break;
        }
    }
    if (runMoreFinalizers) {
        runAllFinalizers();
        halt(status);
    }
    synchronized (Shutdown.class) {
        /* Synchronize on the class object, causing any other thread
         * that attempts to initiate shutdown to stall indefinitely
         */
        sequence();
        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 (lock) {
        switch (state) {
        case RUNNING:       /* Initiate shutdown */
            state = HOOKS;
            break;
        case HOOKS:         /* Stall and then return */
        case FINALIZERS:
            break;
        }
    }
    synchronized (Shutdown.class) {
        sequence();
    }
}

5.Shutdown#runAllFinalizers

Shutdown#runAllFinalizers是个native方法，会调用Finalizer#runAllFinalizers，Finalizer#runAllFinalizers里面会遍历Finalizer链表变量unfinalized，逐个节点执行runFinalizer方法，根据方法体内的注释

Clear stack slot containing this variable, to decrease the chances of false retention with a conservative GC

可以知道这是为了减少gc回收出错几率的方法。

/* Invoked by java.lang.Shutdown */
static void runAllFinalizers() {
    if (!VM.isBooted()) {
        return;
    }

    forkSecondaryFinalizer(new Runnable() {
        private volatile boolean running;
        public void run() {
            if (running)
                return;
            final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
            running = true;
            for (;;) {
                Finalizer f;
                synchronized (lock) {
                    f = unfinalized;
                    if (f == null) break;
                    unfinalized = f.next;
                }
                f.runFinalizer(jla);
            }}});
}

private void runFinalizer(JavaLangAccess jla) {
    synchronized (this) {
        if (hasBeenFinalized()) return;
        remove();
    }
    try {
        Object finalizee = this.get();
        if (finalizee != null && !(finalizee instanceof java.lang.Enum)) {
            jla.invokeFinalize(finalizee);

            /* Clear stack slot containing this variable, to decrease
            /* the chances of false retention with a conservative GC 
            */
            finalizee = null;
        }
    } catch (Throwable x) { }
    super.clear();
}

以上内容梳理了钩子的添加流程，以及由谁去调用钩子。

下面梳理java程序注册信号监听并调用Shutdown.exit的流程。

二、注册信号监听

1.Terminator#setup

jvm对部分信号(HUP/INT/TERM)的默认捕获处理在Terminator类的setup()方法中
以下源码是jdk1.8.0_161的版本，我看了jdk1.8.0_144的setup方法是没有对HUP信号进行处理，不同版本略有差异

/* Invocations of setup and teardown are already synchronized
 * on the shutdown lock, so no further synchronization is needed here
 */

static void setup() {
    if (handler != null) return;
    SignalHandler sh = new SignalHandler() {
        public void handle(Signal sig) {
            Shutdown.exit(sig.getNumber() + 0200);
        }
    };
    handler = sh;
    // When -Xrs is specified the user is responsible for
    // ensuring that shutdown hooks are run by calling
    // System.exit()
    try {
        Signal.handle(new Signal("HUP"), sh);
    } catch (IllegalArgumentException e) {
    }
    try {
        Signal.handle(new Signal("INT"), sh);
    } catch (IllegalArgumentException e) {
    }
    try {
        Signal.handle(new Signal("TERM"), sh);
    } catch (IllegalArgumentException e) {
    }
}

2.System#initializeSystemClass

Terminator类的setup()方法由System类初始化的时候在initializeSystemClass方法里调用

/**
 * Initialize the system class.  Called after thread initialization.
 */
private static void initializeSystemClass() {

    // VM might invoke JNU_NewStringPlatform() to set those encoding
    // sensitive properties (user.home, user.name, boot.class.path, etc.)
    // during "props" initialization, in which it may need access, via
    // System.getProperty(), to the related system encoding property that
    // have been initialized (put into "props") at early stage of the
    // initialization. So make sure the "props" is available at the
    // very beginning of the initialization and all system properties to
    // be put into it directly.
    props = new Properties();
    initProperties(props);  // initialized by the VM

    // There are certain system configurations that may be controlled by
    // VM options such as the maximum amount of direct memory and
    // Integer cache size used to support the object identity semantics
    // of autoboxing.  Typically, the library will obtain these values
    // from the properties set by the VM.  If the properties are for
    // internal implementation use only, these properties should be
    // removed from the system properties.
    //
    // See java.lang.Integer.IntegerCache and the
    // sun.misc.VM.saveAndRemoveProperties method for example.
    //
    // Save a private copy of the system properties object that
    // can only be accessed by the internal implementation.  Remove
    // certain system properties that are not intended for public access.
    sun.misc.VM.saveAndRemoveProperties(props);


    lineSeparator = props.getProperty("line.separator");
    sun.misc.Version.init();

    FileInputStream fdIn = new FileInputStream(FileDescriptor.in);
    FileOutputStream fdOut = new FileOutputStream(FileDescriptor.out);
    FileOutputStream fdErr = new FileOutputStream(FileDescriptor.err);
    setIn0(new BufferedInputStream(fdIn));
    setOut0(newPrintStream(fdOut, props.getProperty("sun.stdout.encoding")));
    setErr0(newPrintStream(fdErr, props.getProperty("sun.stderr.encoding")));

    // Load the zip library now in order to keep java.util.zip.ZipFile
    // from trying to use itself to load this library later.
    loadLibrary("zip");

    // Setup Java signal handlers for HUP, TERM, and INT (where available).
    Terminator.setup();

    // Initialize any miscellenous operating system settings that need to be
    // set for the class libraries. Currently this is no-op everywhere except
    // for Windows where the process-wide error mode is set before the java.io
    // classes are used.
    sun.misc.VM.initializeOSEnvironment();

    // The main thread is not added to its thread group in the same
    // way as other threads; we must do it ourselves here.
    Thread current = Thread.currentThread();
    current.getThreadGroup().add(current);

    // register shared secrets
    setJavaLangAccess();

    // Subsystems that are invoked during initialization can invoke
    // sun.misc.VM.isBooted() in order to avoid doing things that should
    // wait until the application class loader has been set up.
    // IMPORTANT: Ensure that this remains the last initialization action!
    sun.misc.VM.booted();
}

System类的initializeSystemClass方法由虚拟机调用
public final class System {

    /* register the natives via the static initializer.
     *
     * VM will invoke the initializeSystemClass method to complete
     * the initialization for this class separated from clinit.
     * Note that to use properties set by the VM, see the constraints
     * described in the initializeSystemClass method.
     */
    private static native void registerNatives();
    static {
        registerNatives();
    }

Terminator类的setup()方法做了信号注册，并且由虚拟机通过调用System类的initializeSystemClass方法方式实现了对Terminator#setup()的调用完成信号注册。
信号注册流程调用链：VM->System#initializeSystemClass()->Terminator#setup()。