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

从这个方法中取出所有的Thread,然后将线程启动起来，最后通过join()方法等待各个线程结束动作。换句话说，在线程关闭前，对多个回调任务的处理方式是每个任务单独有一个线程处理，而不是所有的任务在一个线程中串行处理。

• Runtime.getRuntime().removeShutdownHook用于删除一个钩子线程。

转载自：http://www.cnblogs.com/nexiyi/p/java_add_ShutdownHook.html
Java特种兵