常见Java应用如何优雅关闭

一、前言

创新互联建站主营徽县网站建设的网络公司,主营网站建设方案,成都App定制开发,徽县h5成都小程序开发搭建,徽县网站营销推广欢迎徽县等地区企业咨询

在我们进行系统升级的时候，往往需要关闭我们的应用，然后重启。在关闭应用前，我们希望做一些前置操作，比如关闭数据库、redis连接，清理zookeeper的临时节点，释放分布式锁，持久化缓存数据等等。

二、Linux的信号机制

在linux上，我们关闭进程主要是使用 kill 的方式。

当执行该命令以后，linux会向进程发送一个信号，进程收到以后之后，可以做一些清理工作。

kill 命令默认的信号值为 15 ，即 SIGTERM 信号。

通过 kill -l 查看linux支持哪些信号：

linux提供了 signal() api，可以将信号处理函数注册上去：

 
 
 
 
    
  
  
  
  
  1. #include  
    2.   
  
  
  
  2. #include  
    3.   
  
  
  
  3. #include  
    4.   
  
  
  
  4. #include  
    5.   
  
  
  
  5. #include  
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. static void gracefulClose(int sig)   
    8.   
  
  
  
  8. { 
    9.   
  
  
  
  9.     printf("执行清理工作\n"); 
    10.   
  
  
  
  10.     printf("JVM 已关闭\n"); 
    11.   
  
  
  
  11.     exit(0);    //正常关闭 
    12.   
  
  
  
  12. } 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14. int main(int argc,char *argv[])   
    15.   
  
  
  
  15. { 
    16.   
  
  
  
  16.     if(signal(SIGTERM,gracefulClose) == SIG_ERR) 
    17.   
  
  
  
  17.         exit(-1); 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.     printf("JVM 已启动\n"); 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.     while(true) 
    22.   
  
  
  
  22.     { 
    23.   
  
  
  
  23.         // 执行工作 
    24.   
  
  
  
  24.         sleep(1); 
    25.   
  
  
  
  25.     } 
    26.   
  
  
  
  26. } 
    27.

三、Java提供的Shutdown Hook

Java并不支持类似于linux的信号机制，但是提供了 Runtime.addShutdownHook(Thread hook) 的api。

在JVM关闭前，会并发执行各个Hook线程。

 
 
 
 
    
  
  
  
  
  1. public class ShutdownHook { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     public static void main(String[] args) throws InterruptedException { 
    4.   
  
  
  
  4.         Runtime.getRuntime().addShutdownHook(new DbShutdownWork()); 
    5.   
  
  
  
  5.         System.out.println("JVM 已启动"); 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7.         while(true){ 
    8.   
  
  
  
  8.             Thread.sleep(10L); 
    9.   
  
  
  
  9.         } 
    10.   
  
  
  
  10.     } 
    11.   
  
  
  
  11.  
    12.   
  
  
  
  12.     static class DbShutdownWork extends Thread{ 
    13.   
  
  
  
  13.         public void run(){ 
    14.   
  
  
  
  14.             System.out.println("关闭数据库连接"); 
    15.   
  
  
  
  15.         } 
    16.   
  
  
  
  16.     } 
    17.   
  
  
  
  17. } 
    18.

四、Spring Boot提供的优雅关闭功能

我们一般采用如下的方式，启动一个Spring boot应用：

 
 
 
 
    
  
  
  
  
  1. public static void main(String[] args) throws Exception {   
    2.   
  
  
  
  2.     SpringApplication.run(SampleController.class, args); 
    3.   
  
  
  
  3. } 
    4.

SpringApplication.run()代码如下，会调用到refreshContext(context)方法：

 
 
 
 
    
  
  
  
  
  1. public ConfigurableApplicationContext run(String... args) {   
    2.   
  
  
  
  2.     StopWatch stopWatch = new StopWatch(); 
    3.   
  
  
  
  3.     stopWatch.start(); 
    4.   
  
  
  
  4.     ConfigurableApplicationContext context = null; 
    5.   
  
  
  
  5.     FailureAnalyzers analyzers = null; 
    6.   
  
  
  
  6.     configureHeadlessProperty(); 
    7.   
  
  
  
  7.     SpringApplicationRunListeners listeners = getRunListeners(args); 
    8.   
  
  
  
  8.     listeners.started(); 
    9.   
  
  
  
  9.     try { 
    10.   
  
  
  
  10.         ApplicationArguments applicationArguments = new DefaultApplicationArguments( 
    11.   
  
  
  
  11.                 args); 
    12.   
  
  
  
  12.         ConfigurableEnvironment environment = prepareEnvironment(listeners, 
    13.   
  
  
  
  13.                 applicationArguments); 
    14.   
  
  
  
  14.         Banner printedBanner = printBanner(environment); 
    15.   
  
  
  
  15.         context = createApplicationContext(); 
    16.   
  
  
  
  16.         analyzers = new FailureAnalyzers(context); 
    17.   
  
  
  
  17.         prepareContext(context, environment, listeners, applicationArguments, 
    18.   
  
  
  
  18.                 printedBanner); 
    19.   
  
  
  
  19.         refreshContext(context); 
    20.   
  
  
  
  20.         afterRefresh(context, applicationArguments); 
    21.   
  
  
  
  21.         listeners.finished(context, null); 
    22.   
  
  
  
  22.         stopWatch.stop(); 
    23.   
  
  
  
  23.         if (this.logStartupInfo) { 
    24.   
  
  
  
  24.             new StartupInfoLogger(this.mainApplicationClass) 
    25.   
  
  
  
  25.                     .logStarted(getApplicationLog(), stopWatch); 
    26.   
  
  
  
  26.         } 
    27.   
  
  
  
  27.         return context; 
    28.   
  
  
  
  28.     } 
    29.   
  
  
  
  29.     catch (Throwable ex) { 
    30.   
  
  
  
  30.         handleRunFailure(context, listeners, analyzers, ex); 
    31.   
  
  
  
  31.         throw new IllegalStateException(ex); 
    32.   
  
  
  
  32.     } 
    33.   
  
  
  
  33. } 
    34.

refreshContext()方法比较简单：

 
 
 
 
    
  
  
  
  
  1. private void refreshContext(ConfigurableApplicationContext context) {   
    2.   
  
  
  
  2.     refresh(context);   //调用ApplicationContext.refresh() 
    3.   
  
  
  
  3.     if (this.registerShutdownHook) {        //registerShutdownHook默认值为true 
    4.   
  
  
  
  4.         try { 
    5.   
  
  
  
  5.             context.registerShutdownHook(); 
    6.   
  
  
  
  6.         } 
    7.   
  
  
  
  7.         catch (AccessControlException ex) { 
    8.   
  
  
  
  8.             // Not allowed in some environments. 
    9.   
  
  
  
  9.         } 
    10.   
  
  
  
  10.     } 
    11.   
  
  
  
  11. } 
    12.

AbstractApplicationContext.registerShutdownHook()代码：

 
 
 
 
    
  
  
  
  
  1. public void registerShutdownHook() {   
    2.   
  
  
  
  2.     if (this.shutdownHook == null) { 
    3.   
  
  
  
  3.         this.shutdownHook = new Thread() { 
    4.   
  
  
  
  4.             @Override 
    5.   
  
  
  
  5.             public void run() { 
    6.   
  
  
  
  6.                 synchronized (startupShutdownMonitor) { 
    7.   
  
  
  
  7.                     doClose(); 
    8.   
  
  
  
  8.                 } 
    9.   
  
  
  
  9.             } 
    10.   
  
  
  
  10.         }; 
    11.   
  
  
  
  11.         Runtime.getRuntime().addShutdownHook(this.shutdownHook); 
    12.   
  
  
  
  12.     } 
    13.   
  
  
  
  13. } 
    14.

很明显，Spring boot通过在启动时，向JVM注册一个ShutdownHook，从而实现JVM关闭前，正常关闭Spring容器。而Spring在销毁时，会依次调用bean的destroy动作来销毁。

五、Dubbo的优雅关闭策略

Dubbo同样是基于ShutdownHook实现的。

AbstractConfig的static代码：

 
 
 
 
    
  
  
  
  
  1. static {   
    2.   
  
  
  
  2.     Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() { 
    3.   
  
  
  
  3.         public void run() { 
    4.   
  
  
  
  4.             if (logger.isInfoEnabled()) { 
    5.   
  
  
  
  5.                 logger.info("Run shutdown hook now."); 
    6.   
  
  
  
  6.             } 
    7.   
  
  
  
  7.             ProtocolConfig.destroyAll(); 
    8.   
  
  
  
  8.         } 
    9.   
  
  
  
  9.     }, "DubboShutdownHook")); 
    10.   
  
  
  
  10. } 
    11.

六、总结

只要我们的应用运行在linux平台上，所有的优雅关闭方案都是基于linux提供的信号机制提供的,JVM也是如此。

Java并没有为我们提供与之一一对应的api，而是给出了个ShutdownHook机制，也能达到类似的效果，缺点是我们无法得知JVM关闭的原因。

像dubbo、spring boot等成熟的开源框架，都实现了自动注册ShutdownHook的功能，从而避免使用者忘记调用优雅关闭api引发问题，降低框架的使用难度。

分享名称：常见Java应用如何优雅关闭
标题来源：http://www.csdahua.cn/qtweb/news35/51835.html

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

广告

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

成都快上网为您推荐相关内容

网页设计公司知识

同城分类信息

成都网站推广　　 　自适应网站建设　　 　云服务器　　 　宇仓仓储　　 　边坡防护网厂家　　 　香港空间　　 　德阳东方电机技改服务有限公司　　 　校园网站建设方案　　 　四川绵阳机房　　 　成都广告公司　　 　重庆建站　　 　微官网开发　　 　子晨木包装箱　　 　重庆网站制作　　 　成都app制作　　 　和县翔豪网站　　 　四川雕琢时光　　 　网络推广公司　　 　重庆电信五里店机房　　 　成都网站制作