Jvm的关闭钩子探险
JVM中我们可以通过Runtime类中的addShutdownHook来注册一些JVM关闭前的回调事件，用来做一些清理操作。
比如在Spring中会使用这个方法来注册自己的回调事件，用来销毁Bean和关闭容器。代码来自org.springframework.context.support.AbstractApplicationContext：
/**
* Register a shutdown hook {@linkplain Thread#getName() named}
* {@code SpringContextShutdownHook} with the JVM runtime, closing this
* context on JVM shutdown unless it has already been closed at that time.
* <p>Delegates to {@code doClose()} for the actual closing procedure.
* @see Runtime#addShutdownHook
* @see ConfigurableApplicationContext#SHUTDOWN_HOOK_THREAD_NAME
* @see #close()
* @see #doClose()
*/
@Override
public void registerShutdownHook() {
if (this.shutdownHook == null) {
// No shutdown hook registered yet.
this.shutdownHook = new Thread(SHUTDOWN_HOOK_THREAD_NAME) {
@Override
public void run() {
synchronized (startupShutdownMonitor) {
doClose();
}
}
};
Runtime.getRuntime().addShutdownHook(this.shutdownHook);
}
}
来看一下具体注册钩子的代码。所谓的钩子是一个构造好但是还没有开始执行的线程。在JVM关闭之前，这些线程会被调用start方法执行。
public void addShutdownHook(Thread hook) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("shutdownHooks"));
}
ApplicationShutdownHooks.add(hook);
}
跟踪源码进去，可以看到。
class ApplicationShutdownHooks {
/* The set of registered hooks */
private static IdentityHashMap<Thread, Thread> hooks;
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);
}
}
上面的方法要求钩子不能为空，且钩子不能启动，且构子没有被注册过。
由于是通过Map来保存钩子，因此自然可以删除掉已经注册的钩子：
class ApplicationShutdownHooks {
/* 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;
}
}
具体调用这些构子的代码如下：
class ApplicationShutdownHooks {
/* 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) {
}
}
}
}
}
它会保证只有一个线程可以执行回调，其余线程在调用hooks.keySet()的时候会抛出空指针异常。
可以发现在函数退出前，需要保证所有构子都完成了自己的使命。当前线程会等待所有构子线程的结束。因此我们不应该在钩子代码中执行一些死循环等可能引起长时间阻塞的代码，只应该放一些轻量级的必要清理操作。
那么谁会调动上面这个runHooks代码呢，在ApplicationShutdownHooks的static代码块中有这样的代码：
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又是何方神圣呢，我们继续追踪代码。
// 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];
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;
}
}
可以看到add实际上只是往hooks[slot]里面放入注册事件。那么真正的事件是啥时候被调用呢。
/* 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;
}
}
}
}
上面这段代码会把所有非空的放在hooks中的Runnable对象执行掉。而runHooks会在sequence方法中被调用。由于Runnable方法是同步执行的，因此所有的任务都是按照注册位置顺序执行的。
/* 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();
}
那sequence在哪里被调用呢？它会在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.
*/
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();
}
}
而shutdown又是什么时候被调用呢？在所有存活线程都是后台线程的时候，DestroyJavaVM这个JNI会被调用，此时shutdown被它调用。
先看看JVM类结构的定义：
struct JNIInvokeInterface_ {
void *reserved0;
void *reserved1;
void *reserved2;
jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
};
struct JavaVM_ {
const struct JNIInvokeInterface_ *functions;
#ifdef __cplusplus
jint DestroyJavaVM() {
return functions->DestroyJavaVM(this);
}
jint AttachCurrentThread(void **penv, void *args) {
return functions->AttachCurrentThread(this, penv, args);
}
jint DetachCurrentThread() {
return functions->DetachCurrentThread(this);
}
jint GetEnv(void **penv, jint version) {
return functions->GetEnv(this, penv, version);
}
jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
return functions->AttachCurrentThreadAsDaemon(this, penv, args);
}
#endif
};
下面我们需要具体看一下JNIInvokeInterface_，它使用的策略模式，具体的调用方法还不清晰。
可以在jni.c文件中找到JNIInvokeInterface_对象的构造过程：
const struct JNIInvokeInterface_ jni_InvokeInterface = {
NULL,
NULL,
NULL,
jni_DestroyJavaVM,
jni_AttachCurrentThread,
jni_DetachCurrentThread,
jni_GetEnv,
jni_AttachCurrentThreadAsDaemon
};
struct JavaVM_ main_vm = {&jni_InvokeInterface};
因此可以确定真正负责销毁虚拟机的函数是jni_DestroyJavaVM，我们看一下其实现。
jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
jint result = JNI_ERR;
// On Windows, we need SEH protection
#ifdef _WIN32
__try {
#endif
result = jni_DestroyJavaVM_inner(vm);
#ifdef _WIN32
} __except(topLevelExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) {
// Nothing to do.
}
#endif
return result;
}
static jint JNICALL jni_DestroyJavaVM_inner(JavaVM *vm) {
HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm);
jint res = JNI_ERR;
DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
if (vm_created == 0) {
res = JNI_ERR;
return res;
}
JNIWrapper("DestroyJavaVM");
JNIEnv *env;
JavaVMAttachArgs destroyargs;
destroyargs.version = CurrentVersion;
destroyargs.name = (char *)"DestroyJavaVM";
destroyargs.group = NULL;
res = vm->AttachCurrentThread((void **)&env, (void *)&destroyargs);
if (res != JNI_OK) {
return res;
}
// Since this is not a JVM_ENTRY we have to set the thread state manually before entering.
JavaThread* thread = JavaThread::current();
ThreadStateTransition::transition_from_native(thread, _thread_in_vm);
//这里执行销毁流程
if (Threads::destroy_vm()) {
// Should not change thread state, VM is gone
vm_created = 0;
res = JNI_OK;
return res;
} else {
ThreadStateTransition::transition(thread, _thread_in_vm, _thread_in_native);
res = JNI_ERR;
return res;
}
}
看一下Threads::destroy_vm的实现。
bool Threads::destroy_vm() {
JavaThread* thread = JavaThread::current();
#ifdef ASSERT
_vm_complete = false;
#endif
// Wait until we are the last non-daemon thread to execute
{ MonitorLocker nu(Threads_lock);
//这里要等到最后只有自己一个非后台线程存活
while (Threads::number_of_non_daemon_threads() > 1)
// This wait should make safepoint checks, wait without a timeout,
// and wait as a suspend-equivalent condition.
nu.wait(0, Mutex::_as_suspend_equivalent_flag);
}
EventShutdown e;
if (e.should_commit()) {
e.set_reason("No remaining non-daemon Java threads");
e.commit();
}
// Hang forever on exit if we are reporting an error.
if (ShowMessageBoxOnError && VMError::is_error_reported()) {
os::infinite_sleep();
}
os::wait_for_keypress_at_exit();
// run Java level shutdown hooks
//这里会执行java层面的钩子
thread->invoke_shutdown_hooks();
//之后推出前做些清理
before_exit(thread);
//真正的推出
thread->exit(true);
// We are no longer on the main thread list but could still be in a
// secondary list where another thread may try to interact with us.
// So wait until all such interactions are complete before we bring
// the VM to the termination safepoint. Normally this would be done
// using thread->smr_delete() below where we delete the thread, but
// we can't call that after the termination safepoint is active as
// we will deadlock on the Threads_lock. Once all interactions are
// complete it is safe to directly delete the thread at any time.
ThreadsSMRSupport::wait_until_not_protected(thread);
// Stop VM thread.
{
// 4945125 The vm thread comes to a safepoint during exit.
// GC vm_operations can get caught at the safepoint, and the
// heap is unparseable if they are caught. Grab the Heap_lock
// to prevent this. The GC vm_operations will not be able to
// queue until after the vm thread is dead. After this point,
// we'll never emerge out of the safepoint before the VM exits.
MutexLocker ml(Heap_lock, Mutex::_no_safepoint_check_flag);
VMThread::wait_for_vm_thread_exit();
assert(SafepointSynchronize::is_at_safepoint(), "VM thread should exit at Safepoint");
VMThread::destroy();
}
// Now, all Java threads are gone except daemon threads. Daemon threads
// running Java code or in VM are stopped by the Safepoint. However,
// daemon threads executing native code are still running. But they
// will be stopped at native=>Java/VM barriers. Note that we can't
// simply kill or suspend them, as it is inherently deadlock-prone.
VM_Exit::set_vm_exited();
// Clean up ideal graph printers after the VMThread has started
// the final safepoint which will block all the Compiler threads.
// Note that this Thread has already logically exited so the
// clean_up() function's use of a JavaThreadIteratorWithHandle
// would be a problem except set_vm_exited() has remembered the
// shutdown thread which is granted a policy exception.
#if defined(COMPILER2) && !defined(PRODUCT)
IdealGraphPrinter::clean_up();
#endif
notify_vm_shutdown();
// exit_globals() will delete tty
exit_globals();
// Deleting the shutdown thread here is safe. See comment on
// wait_until_not_protected() above.
delete thread;
#if INCLUDE_JVMCI
if (JVMCICounterSize > 0) {
FREE_C_HEAP_ARRAY(jlong, JavaThread::_jvmci_old_thread_counters);
}
#endif
LogConfiguration::finalize();
return true;
}
具体执行钩子的代码发生在thread->invoke_shutdown_hooks();这行代码，我们进入一窥究竟：
// Last thread running calls java.lang.Shutdown.shutdown()
void JavaThread::invoke_shutdown_hooks() {
HandleMark hm(this);
// Link all classes for dynamic CDS dumping before vm exit.
// Same operation is being done in JVM_BeforeHalt for handling the
// case where the application calls System.exit().
if (DynamicDumpSharedSpaces) {
MetaspaceShared::link_and_cleanup_shared_classes(this);
}
// We could get here with a pending exception, if so clear it now.
if (this->has_pending_exception()) {
this->clear_pending_exception();
}
EXCEPTION_MARK;
Klass* shutdown_klass =
SystemDictionary::resolve_or_null(vmSymbols::java_lang_Shutdown(),
THREAD);
if (shutdown_klass != NULL) {
// SystemDictionary::resolve_or_null will return null if there was
// an exception. If we cannot load the Shutdown class, just don't
// call Shutdown.shutdown() at all. This will mean the shutdown hooks
// won't be run. Note that if a shutdown hook was registered,
// the Shutdown class would have already been loaded
// (Runtime.addShutdownHook will load it).
JavaValue result(T_VOID);
JavaCalls::call_static(&result,
shutdown_klass,
vmSymbols::shutdown_name(),
vmSymbols::void_method_signature(),
THREAD);
}
CLEAR_PENDING_EXCEPTION;
}
大概就这里结束吧。