java 钩子线程_java-钩子线程

在线上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用于删除一个钩子线程。