在线上Java程序中经常遇到进程程挂掉,一些状态没有正确的保存下来,这时候就需要在JVM关掉的时候执行一些清理现场的代码。Java中得ShutdownHook提供了比较好的方案。
JDK在1.3之后提供了Java Runtime.addShutdownHook(Thread hook)方法,可以注册一个JVM关闭的钩子,这个钩子可以在以下几种场景被调用:
1)程序正常退出
2)使用System.exit()
3)终端使用Ctrl+C触发的中断
4)系统关闭
5)使用Kill pid命令干掉进程
注:在使用kill -9 pid是不会JVM注册的钩子不会被调用。
在JDK中方法的声明:
public void addShutdownHook(Thread hook)
参数
hook – 一个初始化但尚未启动的线程对象,注册到JVM钩子的运行代码。
异常
IllegalArgumentException – 如果指定的钩已被注册,或如果它可以判定钩已经运行或已被运行
IllegalStateException – 如果虚拟机已经是在关闭的过程中
SecurityException – 如果存在安全管理器并且它拒绝的RuntimePermission(“shutdownHooks”)
代码示例:
使用Timer模拟一个工作线程,该线程重复工作十次,使用System.exit()退出,在清理现场代码CleanWorkThread 中,取消timer运行,并输出必要的日志信息。
package com.netease.test.java.lang;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.atomic.AtomicInteger;
/** * Date: 14-6-18 * Time: 11:01 * 测试ShutdownHook */
public class TestShutdownHook {
//简单模拟干活的
static Timer timer = new Timer("job-timer");
//计数干活次数
static AtomicInteger count = new AtomicInteger(0);
/** * hook线程 */
static class CleanWorkThread extends Thread{
@Override
public void run() {
System.out.println("clean some work.");
timer.cancel();
try {
Thread.sleep(2 * 1000);//sleep 2s
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
//将hook线程添加到运行时环境中去
Runtime.getRuntime().addShutdownHook(new CleanWorkThread());
System.out.println("main class start ..... ");
//简单模拟
timer.schedule(new TimerTask() {
@Override
public void run() {
count.getAndIncrement();
System.out.println("doing job " + count);
if (count.get() == 10) { //干了10次退出
System.exit(0);
}
}
}, 0, 2 * 1000);
}
}
当发生了System.exit(int)时,希望在系统退出前,执行一点任务来做一些资源方面的回收操作,ShutdownHook可以达到这个目的,它利用hook思路来实现,有些时候也把它叫作“钩子“。
假如在系统中通过Runtime.getRuntime().exec()或new ProcessBuilde()启动了子进程(Process),这个子进程一直在运行中,在当前进程退出时,子进程未必会退出,但此时业务上希望将它退出,就可以利用这一点。例如可以这样写:
Runtime.getRuntime().addShutdownHook()
{
new Thread()
{
public void run()
{
processer.destroy();
}
}
}
这里需要注意的是,传入参数是通过new Thread()创建的线程对象,在Java进程调用exit()时,会调用该线程对象的start()方法将其运行起来,所以不要手工先启动了。另外,这种回调线程就不要设定为死循环程序,否则就无法退出了。
再简单阐述下原理,大家也可以自行分析源码得到答案。
java.lang包下有一个Shutdown类,提供了一个Runnable []hooks数组,数组的长度为10,也就是最多定义10个hook(这与程序写入多少个线程回调没有关系,下面会介绍,提供add()方法来注册新的hook对象)
在java.lang.ApplicationShutdownHooks的static匿名块中,通过add()方法注册了一个hook,在run()方法内部的静态方法runHooks(),它内部用一个IdentityHashMap来存放hook信息,可以通过add()方法来添加,而程序中定义的回调线程都放在了这里,它自身用hook的形式存放在于hooks列表中,如下所示:
class ApplicationShutdownHooks
{
static
{
Shutdown.add(1 /* shutdown hook invocation order*/,
new Runnable()
{
public void run()
{
runHooks();
}
}
);
}
}
当调用Runnable.getRunnable().addShutdownHook(Thread)方法时,会间接调用ApplicationShutdownHooks.add(Thread)将线程放到IdentityHashMap中。
当调用System.exit(int)方法时,会间接调用Shutdown.exit(int)方法,再调用sequence()->runHooks()方法,调用如下所示:
/* 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;
}
}
}
}
循环中的一个hook对象就是由ApplicationShutdownHooks的匿名块定义的,因此会调用ApplicationShutdownHooks类的run()方法,再调用它的runHooks()方法,这个runHooks()方法如下所示:
/* 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) { }
}
}
从这个方法中取出所有的Thread,然后将线程启动起来,最后通过join()方法等待各个线程结束动作。换句话说,在线程关闭前,对多个回调任务的处理方式是每个任务单独有一个线程处理,而不是所有的任务在一个线程中串行处理。
Runtime.getRuntime().removeShutdownHook用于删除一个钩子线程。