java ShutdownHook(钩子线程)

小鱼儿 2022-03-08 00:40 199阅读 0赞

在线上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][http_www.cnblogs.com_nexiyi_p_java_add_ShutdownHook.html]

[http_www.cnblogs.com_nexiyi_p_java_add_ShutdownHook.html]: http://www.cnblogs.com/nexiyi/p/java_add_ShutdownHook.html