聊一下ShutdownHook原理

[[394735]]

ShutdownHook介绍

在java程序中，很容易在进程结束时添加一个钩子，即ShutdownHook。通常在程序启动时加入以下代码即可

网站建设哪家好，找创新互联公司！专注于网页设计、网站建设、微信开发、小程序开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了玉溪免费建站欢迎大家使用！

 
 
 
 
    
  
  
  
  
  1. Runtime.getRuntime().addShutdownHook(new Thread(){ 
    2. 
  
  
  
  
  2.     @Override 
    3. 
  
  
  
  
  3.     public void run() { 
    4. 
  
  
  
  
  4.         System.out.println("I'm shutdown hook..."); 
    5. 
  
  
  
  
  5.     } 
    6. 
  
  
  
  
  6. }); 
    7.

有了ShutdownHook我们可以

  • 在进程结束时做一些善后工作，例如释放占用的资源，保存程序状态等
  • 为优雅(平滑)发布提供手段，在程序关闭前摘除流量

不少java中间件或框架都使用了ShutdownHook的能力，如dubbo、spring等。

spring在application context被load时会注册一个ShutdownHook。这个ShutdownHook会在进程退出前执行销毁bean，发出ContextClosedEvent等动作。而dubbo在spring框架下正是监听了ContextClosedEvent，调用dubboBootstrap.stop()来实现清理现场和dubbo的优雅发布，spring的事件机制默认是同步的，所以能在publish事件时等待所有监听者执行完毕。

ShutdownHook原理

ShutdownHook的数据结构与执行顺序

  • 当我们添加一个ShutdownHook时，会调用ApplicationShutdownHooks.add(hook)，往ApplicationShutdownHooks类下的静态变量private static IdentityHashMap
  • ApplicationShutdownHooks类初始化时会把hooks添加到Shutdown的hooks中去，而Shutdown的hooks是系统级的ShutdownHook，并且系统级的ShutdownHook由一个数组构成，只能添加10个
  • 系统级的ShutdownHook调用了thread类的run方法，所以系统级的ShutdownHook是同步有序执行的
 
 
 
 
    
  
  
  
  
  1. private static void runHooks() { 
    2. 
  
  
  
  
  2.     for (int i=0; i < MAX_SYSTEM_HOOKS; i++) { 
    3. 
  
  
  
  
  3.         try { 
    4. 
  
  
  
  
  4.             Runnable hook; 
    5. 
  
  
  
  
  5.             synchronized (lock) { 
    6. 
  
  
  
  
  6.                 // acquire the lock to make sure the hook registered during 
    7. 
  
  
  
  
  7.                 // shutdown is visible here. 
    8. 
  
  
  
  
  8.                 currentRunningHook = i; 
    9. 
  
  
  
  
  9.                 hook = hooks[i]; 
    10. 
  
  
  
  
  10.             } 
    11. 
  
  
  
  
  11.             if (hook != null) hook.run(); 
    12. 
  
  
  
  
  12.         } catch(Throwable t) { 
    13. 
  
  
  
  
  13.             if (t instanceof ThreadDeath) { 
    14. 
  
  
  
  
  14.                 ThreadDeath td = (ThreadDeath)t; 
    15. 
  
  
  
  
  15.                 throw td; 
    16. 
  
  
  
  
  16.             } 
    17. 
  
  
  
  
  17.         } 
    18. 
  
  
  
  
  18.     } 
    19. 
  
  
  
  
  19. } 
    20.
  • 系统级的ShutdownHook的add方法是包可见，即我们不能直接调用它
  • ApplicationShutdownHooks位于下标1处，且应用级的hooks，执行时调用的是thread类的start方法，所以应用级的ShutdownHook是异步执行的，但会等所有hook执行完毕才会退出。
 
 
 
 
    
  
  
  
  
  1. static void runHooks() { 
    2. 
  
  
  
  
  2.     Collection threads; 
    3. 
  
  
  
  
  3.     synchronized(ApplicationShutdownHooks.class) { 
    4. 
  
  
  
  
  4.         threads = hooks.keySet(); 
    5. 
  
  
  
  
  5.         hooks = null; 
    6. 
  
  
  
  
  6.     } 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.     for (Thread hook : threads) { 
    9. 
  
  
  
  
  9.         hook.start(); 
    10. 
  
  
  
  
  10.     } 
    11. 
  
  
  
  
  11.     for (Thread hook : threads) { 
    12. 
  
  
  
  
  12.         while (true) { 
    13. 
  
  
  
  
  13.             try { 
    14. 
  
  
  
  
  14.                 hook.join(); 
    15. 
  
  
  
  
  15.                 break; 
    16. 
  
  
  
  
  16.             } catch (InterruptedException ignored) { 
    17. 
  
  
  
  
  17.             } 
    18. 
  
  
  
  
  18.         } 
    19. 
  
  
  
  
  19.     } 
    20. 
  
  
  
  
  20. } 
    21.

用一副图总结如下：

ShutdownHook触发点

从Shutdown的runHooks顺藤摸瓜，我们得出以下两个调用路径

重点看Shutdown.exit 和 Shutdown.shutdown

Shutdown.exit

跟进Shutdown.exit的调用方，发现有 Runtime.exit 和 Terminator.setup

  • Runtime.exit 是代码中主动结束进程的接口
  • Terminator.setup 被 initializeSystemClass 调用，当第一个线程被初始化的时候被触发，触发后注册一个信号监听函数，捕获kill发出的信号，调用Shutdown.exit结束进程

这样覆盖了代码中主动结束进程和被kill杀死进程的场景。

主动结束进程不必介绍，这里说一下信号捕获。在java中我们可以写出如下代码来捕获kill信号，只需要实现SignalHandler接口以及handle方法，程序入口处注册要监听的信号即可，当然不是每个信号都能捕获处理。

 
 
 
 
    
  
  
  
  
  1. public class SignalHandlerTest implements SignalHandler { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     public static void main(String[] args) { 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.         Runtime.getRuntime().addShutdownHook(new Thread() { 
    6. 
  
  
  
  
  6.             @Override 
    7. 
  
  
  
  
  7.             public void run() { 
    8. 
  
  
  
  
  8.                 System.out.println("I'm shutdown hook "); 
    9. 
  
  
  
  
  9.             } 
    10. 
  
  
  
  
  10.         }); 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.         SignalHandler sh = new SignalHandlerTest(); 
    13. 
  
  
  
  
  13.         Signal.handle(new Signal("HUP"), sh); 
    14. 
  
  
  
  
  14.         Signal.handle(new Signal("INT"), sh); 
    15. 
  
  
  
  
  15.         //Signal.handle(new Signal("QUIT"), sh);// 该信号不能捕获 
    16. 
  
  
  
  
  16.         Signal.handle(new Signal("ABRT"), sh); 
    17. 
  
  
  
  
  17.         //Signal.handle(new Signal("KILL"), sh);// 该信号不能捕获 
    18. 
  
  
  
  
  18.         Signal.handle(new Signal("ALRM"), sh); 
    19. 
  
  
  
  
  19.         Signal.handle(new Signal("TERM"), sh); 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21.         while (true) { 
    22. 
  
  
  
  
  22.             System.out.println("main running"); 
    23. 
  
  
  
  
  23.             try { 
    24. 
  
  
  
  
  24.                 Thread.sleep(2000L); 
    25. 
  
  
  
  
  25.             } catch (InterruptedException e) { 
    26. 
  
  
  
  
  26.                 e.printStackTrace(); 
    27. 
  
  
  
  
  27.             } 
    28. 
  
  
  
  
  28.         } 
    29. 
  
  
  
  
  29.     } 
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31.     @Override 
    32. 
  
  
  
  
  32.     public void handle(Signal signal) { 
    33. 
  
  
  
  
  33.         System.out.println("receive signal " + signal.getName() + "-" + signal.getNumber()); 
    34. 
  
  
  
  
  34.         System.exit(0); 
    35. 
  
  
  
  
  35.     } 
    36. 
  
  
  
  
  36. } 
    37.

要注意的是，通常来说我们捕获信号，做了一些个性化的处理后需要主动调用System.exit，否则进程就不会退出了，这时只能使用kill -9来强制杀死进程了。

而且每次信号的捕获是在不同的线程中，所以他们之间的执行是异步的。

Shutdown.shutdown

这个方法可以看注释

 
 
 
 
    
  
  
  
  
  1. /* Invoked by the JNI DestroyJavaVM procedure when the last non-daemon 
    2. 
  
  
  
  
  2.   * thread has finished.  Unlike the exit method, this method does not 
    3. 
  
  
  
  
  3.   * actually halt the VM. 
    4. 
  
  
  
  
  4.   */ 
    5.

翻译一下就是该方法会在最后一个非daemon线程(非守护线程)结束时被JNI的DestroyJavaVM方法调用。

java中有两类线程，用户线程和守护线程，守护线程是服务于用户线程，如GC线程，JVM判断是否结束的标志就是是否还有用户线程在工作。当最后一个用户线程结束时，就会调用 Shutdown.shutdown。这是JVM这类虚拟机语言特有的"权利"，倘若是golang这类编译成可执行的二进制文件时，当全部用户线程结束时是不会执行ShutdownHook的。

举个例子，当java进程正常退出时，没有在代码中主动结束进程，也没有kill，就像这样

 
 
 
 
    
  
  
  
  
  1. public static void main(String[] args) { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     Runtime.getRuntime().addShutdownHook(new Thread() { 
    4. 
  
  
  
  
  4.         @Override 
    5. 
  
  
  
  
  5.         public void run() { 
    6. 
  
  
  
  
  6.             System.out.println("I'm shutdown hook "); 
    7. 
  
  
  
  
  7.         } 
    8. 
  
  
  
  
  8.     }); 
    9. 
  
  
  
  
  9. } 
    10.

当main线程运行完了后，也能打印出I'm shutdown hook，反观golang就做不到这一点

通过如上两个调用的分析，我们概括出如下结论：

我们能看出java的ShutdownHook其实覆盖的非常全面了，只有一处无法覆盖，即当我们杀死进程时使用了kill -9时，由于程序无法捕获处理，进程被直接杀死，所以无法执行ShutdownHook。

总结

综上，我们得出一些结论

  • 重写捕获信号需要注意主动退出进程，否则进程可能永远不会退出，捕获信号的执行是异步的
  • 用户级的ShutdownHook是绑定在系统级的ShutdownHook之上，且用户级是异步执行，系统级是同步顺序执行，用户级处于系统级执行顺序的第二位
  • ShutdownHook 覆盖的面比较广，不论是手动调用接口退出进程，还是捕获信号退出进程，抑或是用户线程执行完毕退出，都会执行ShutdownHook，唯一不会执行的就是kill -9

网页题目：聊一下ShutdownHook原理
文章起源：http://www.shufengxianlan.com/qtweb/news20/545370.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站排名知识

各行业网站

高端网站定制　　 　网络营销推广　　 　乐山网站建设　　 　成都服务器托管　　 　成都网站设计　　 　成都网站建设　　 　成都网站建设　　 　网络营销推广　　 　成都网站制作　　 　成都装饰装修　　 　重庆教育培训网站建设　　 　黔盛装饰　　 　东方电机技改服务有限公司　　 　成都小程序开发　　 　轻质隔墙板　　 　乐山网站建设　　 　棕树数据中心　　 　教育培训网站建设方案　　 　网站定制　　 　崇州搬家公司