设计Java应用程序的平滑停止

Java应用程序退出的触发机制有：

创新互联公司服务项目包括古浪网站建设、古浪网站制作、古浪网页制作以及古浪网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，古浪网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到古浪省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

  1. 自动结束：应用没有存活线程或只有后台线程时；
  2. System.exit(0);
  3. kill 或 ctrl+C；
  4. kill -9 强制退出；

如何做到应用程序平滑停止

程序的退出就像关机一样，我们希望关机时平滑关机，保证所有应用程序的数据都保存了。就像现在在写得blog，希望关机的时候能被保存好到草稿箱里。

我们的的Java程序中经常有一种常驻的任务或服务，如消息消费端、服务提供者，我们期望停止也是平滑的不会出现事务执行到一半产生脏数据。

java对这块的支持是通过钩子线程实现。每个Java进程都可以注册钩子线程，钩子线程程在程序退出的前被执行（kill -9强制退出除外）。注册钩子线程代码如下：

 
 
 
    
  
  
  
  1. Runtime.getRuntime().addShutdownHook(t);
    2.

我们可以在钩子线程里做一些善后数据清理等事情，以保证程序是平滑退出的。

一般服务或框架运行都要考虑其生命周期：

如spring容器的context.stop()方法。

再如线程池ExecutorService的shutdown方法，它会保证不接受新任务，并把未执行完的任务做完。

我们再设计服务的时候也要考虑到停止时的stop方法，以便于退出时由钩子线程调用。

注册了钩子线程后，程序收到退出信号后，会保持程序运行，直到钩子线程执行完毕，才把程序的所有线程停止并退出，下面示例代码可以说明这一点：

 
 
 
    
  
  
  
  1. public class ShutDownTest { 
    2. 
  
  
  
  2. 
  
  
  
  3.     public static void main(String[] args) { 
    4. 
  
  
  
  4.         //注册***个钩子 
    5. 
  
  
  
  5.         Runtime.getRuntime().addShutdownHook(new Thread() { 
    6. 
  
  
  
  6. 
  
  
  
  7.             public void run() { 
    8. 
  
  
  
  8.                 try { 
    9. 
  
  
  
  9.                     Thread.currentThread().sleep(5000); 
    10. 
  
  
  
  10.                 } catch (InterruptedException e) { 
    11. 
  
  
  
  11.                     e.printStackTrace(); 
    12. 
  
  
  
  12.                 } 
    13. 
  
  
  
  13.                 System.out.println("clean task1 completed."); 
    14. 
  
  
  
  14.             } 
    15. 
  
  
  
  15.         }); 
    16. 
  
  
  
  16.         //注册第二个钩子 
    17. 
  
  
  
  17.         Runtime.getRuntime().addShutdownHook(new Thread() { 
    18. 
  
  
  
  18. 
  
  
  
  19.             public void run() { 
    20. 
  
  
  
  20.                 try { 
    21. 
  
  
  
  21.                     Thread.currentThread().sleep(10000); 
    22. 
  
  
  
  22.                 } catch (InterruptedException e) { 
    23. 
  
  
  
  23.                     e.printStackTrace(); 
    24. 
  
  
  
  24.                 } 
    25. 
  
  
  
  25.                 System.out.println("clean task2 completed"); 
    26. 
  
  
  
  26.             } 
    27. 
  
  
  
  27.         }); 
    28. 
  
  
  
  28.         //启动子线程 
    29. 
  
  
  
  29.         new Thread() { 
    30. 
  
  
  
  30. 
  
  
  
  31.             public void run() { 
    32. 
  
  
  
  32.                 while (true) { 
    33. 
  
  
  
  33.                     try { 
    34. 
  
  
  
  34.                         Thread.currentThread().sleep(1000); 
    35. 
  
  
  
  35.                         System.out.println("sub thread is running"); 
    36. 
  
  
  
  36.                     } catch (InterruptedException e) { 
    37. 
  
  
  
  37.                         e.printStackTrace(); 
    38. 
  
  
  
  38.                     } 
    39. 
  
  
  
  39.                 } 
    40. 
  
  
  
  40.             } 
    41. 
  
  
  
  41.         }.start(); 
    42. 
  
  
  
  42.         //程序退出 
    43. 
  
  
  
  43.         System.exit(0); 
    44. 
  
  
  
  44.     } 
    45. 
  
  
  
  45. 
  
  
  
  46. }
    47.

程序输出：

 
 
 
    
  
  
  
  1. sub thread is running 
    2. 
  
  
  
  2. sub thread is running 
    3. 
  
  
  
  3. sub thread is running 
    4. 
  
  
  
  4. sub thread is running 
    5. 
  
  
  
  5. clean task1 completed. 
    6. 
  
  
  
  6. sub thread is running 
    7. 
  
  
  
  7. sub thread is running 
    8. 
  
  
  
  8. sub thread is running 
    9. 
  
  
  
  9. sub thread is running 
    10. 
  
  
  
  10. sub thread is running 
    11. 
  
  
  
  11. clean task2 completed
    12.

注意点：钩子线程里只处理善后，目标是尽可能快的退出且不保证有脏数据。如果钩子线程里做过多事情，或者发生阻塞，那么可能出现kill失效，程序不能退出的情况，这是需要强制退出。

如以下程序会导致kill失效，需要强制退出，因为钩子线程阻塞了：

 
 
 
    
  
  
  
  1. public class ShutDownTest { 
    2. 
  
  
  
  2. 
  
  
  
  3.     public static void main(String[] args) { 
    4. 
  
  
  
  4.         //注册钩子 
    5. 
  
  
  
  5.         Runtime.getRuntime().addShutdownHook(new Thread() { 
    6. 
  
  
  
  6.             public void run() { 
    7. 
  
  
  
  7.                 synchronized (ShutdownFileTest.class) { 
    8. 
  
  
  
  8.                     try { 
    9. 
  
  
  
  9.                         ShutdownFileTest.class.wait(); 
    10. 
  
  
  
  10.                     } catch (InterruptedException e) { 
    11. 
  
  
  
  11.                         e.printStackTrace(); 
    12. 
  
  
  
  12.                     } 
    13. 
  
  
  
  13.                 } 
    14. 
  
  
  
  14.             } 
    15. 
  
  
  
  15.         }); 
    16. 
  
  
  
  16.         //启动子线程 
    17. 
  
  
  
  17.         new Thread() { 
    18. 
  
  
  
  18.             public void run() { 
    19. 
  
  
  
  19.                 while (true) { 
    20. 
  
  
  
  20.                     try { 
    21. 
  
  
  
  21.                         Thread.currentThread().sleep(1000); 
    22. 
  
  
  
  22.                         System.out.println("sub thread is running"); 
    23. 
  
  
  
  23.                     } catch (InterruptedException e) { 
    24. 
  
  
  
  24.                         e.printStackTrace(); 
    25. 
  
  
  
  25.                     } 
    26. 
  
  
  
  26.                 } 
    27. 
  
  
  
  27.             } 
    28. 
  
  
  
  28.         }.start(); 
    29. 
  
  
  
  29.        System.exit(0); 
    30. 
  
  
  
  30.        } 
    31. 
  
  
  
  31. 
  
  
  
  32. }
    33.

程序退出机制选择

触发程序退出的在前面已经提到过，但是为了停止方便、安全和优雅，一般我们推荐几种操控性更强的退出机制。常见的推荐机制有以下几种：

1.kill

在linux里用的比较多，向进程发送退出信号，java进程收到后平滑退出。

2.shutdownfile

系统创建一个shutdown file.并监听shutdown file是否存在。如果发现shutdown file不存在了，那么调用System.exit,将程序退出。

如果期望只有特定的人才能终止该程序，那么你可以给文件设定权限，这样就只有特定的人可以终止程序。

以下代码是个简单的例子：

 
 
 
    
  
  
  
  1. import java.io.File; 
    2. 
  
  
  
  2. import java.io.IOException; 
    3. 
  
  
  
  3. 
  
  
  
  4. public class ShutdownFileTest { 
    5. 
  
  
  
  5. 
  
  
  
  6.     public static void main(String[] args) { 
    7. 
  
  
  
  7.         // 启动子线程 
    8. 
  
  
  
  8.         new Thread() { 
    9. 
  
  
  
  9. 
  
  
  
  10.             public void run() { 
    11. 
  
  
  
  11.                 while (true) { 
    12. 
  
  
  
  12.                     try { 
    13. 
  
  
  
  13.                         Thread.currentThread().sleep(1000); 
    14. 
  
  
  
  14.                         System.out.println("sub thread is running"); 
    15. 
  
  
  
  15.                     } catch (InterruptedException e) { 
    16. 
  
  
  
  16.                         e.printStackTrace(); 
    17. 
  
  
  
  17.                     } 
    18. 
  
  
  
  18.                 } 
    19. 
  
  
  
  19.             } 
    20. 
  
  
  
  20.         }.start(); 
    21. 
  
  
  
  21.          
    22. 
  
  
  
  22.         //启动shutdownfile监听线程 
    23. 
  
  
  
  23.         new Thread() { 
    24. 
  
  
  
  24. 
  
  
  
  25.             public void run() { 
    26. 
  
  
  
  26.                 File shutDownFile = new File("a.shutdown"); 
    27. 
  
  
  
  27.                 // create shut down file 
    28. 
  
  
  
  28.                 if (!shutDownFile.exists()) { 
    29. 
  
  
  
  29.                     try { 
    30. 
  
  
  
  30.                         shutDownFile.createNewFile(); 
    31. 
  
  
  
  31.                     } catch (IOException e) { 
    32. 
  
  
  
  32.                         e.printStackTrace(); 
    33. 
  
  
  
  33.                     } 
    34. 
  
  
  
  34.                 } 
    35. 
  
  
  
  35.                 // watch for file deleted then shutdown  
    36. 
  
  
  
  36.                 while (true) { 
    37. 
  
  
  
  37.                     try { 
    38. 
  
  
  
  38.                         if (shutDownFile.exists()) { 
    39. 
  
  
  
  39.                             Thread.currentThread().sleep(1000); 
    40. 
  
  
  
  40.                         } else { 
    41. 
  
  
  
  41.                             System.exit(0); 
    42. 
  
  
  
  42.                         } 
    43. 
  
  
  
  43.                     } catch (InterruptedException e) { 
    44. 
  
  
  
  44.                         e.printStackTrace(); 
    45. 
  
  
  
  45.                     } 
    46. 
  
  
  
  46.                 } 
    47. 
  
  
  
  47.             } 
    48. 
  
  
  
  48.         }.start(); 
    49. 
  
  
  
  49.     } 
    50. 
  
  
  
  50. 
  
  
  
  51. }
    52.

3.打开一个端口，监听端口里的命令，收到命令后调用System.exit。

这个似乎不常见，也比较麻烦。

4.JMX

通过JMX的mbean远程控制来实现。

在这个链接里有看到例子：how-to-stop-java-process-gracefully

本文标题：设计Java应用程序的平滑停止
网页路径：http://www.mswzjz.cn/qtweb/news12/57262.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等

广告

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

贝锐智能技术为您推荐以下文章

响应式网站知识

分类信息网

虚拟主机　　 　重庆做网站　　 　成都关键词SEO优化　　 　成都光彩外墙景观　　 　企业手机网站建设　　 　自适应网站设计　　 　富顺网站建设　　 　成都商城网站建设　　 　网站方案　　 　成都网站运维　　 　网站空间　　 　3D立体画　　 　西部信息机房　　 　无边发光字厂家　　 　成都网站设计　　 　成都云服务器　　 　广告吸塑字　　 　手机网站制作设计　　 　东方电机技改服务有限公司　　 　西部信息服务器托管