哦，这就是java的优雅停机？（实现及原理）

其实优雅停机，就是在要关闭服务之前，不是立马全部关停，而是做好一些善后操作，比如：关闭线程、释放连接资源等。

再比如，就是不会让调用方的请求处理了一增，一下就中断了。而处理完本次后，再停止服务。

Java语言中，我们可以通过Runtime.getRuntime().addShutdownHook()方法来注册钩子，以保证程序平滑退出。（其他语言也类似）

来个栗子:

1. public class ShutdownGracefulTest {

2. 
   

3. /**

4. * 使用线程池处理任务

5. */

6. public static ExecutorService executorService = Executors.newCachedThreadPool();

7. 
   

8. public static void main(String[] args) {

9. 
   

10. //假设有5个线程需要执行任务

11. for(int i = 0; i < 5; i++){

12. final int id = i;

13. Thread taski = new Thread(new Runnable() {

14. @Override

15. public void run() {

16. System.out.println(System.currentTimeMillis() + " : thread_" + id + " start...");

17. try {

18. TimeUnit.SECONDS.sleep(id);

19. }

20. catch (InterruptedException e) {

21. e.printStackTrace();

22. }

23. System.out.println(System.currentTimeMillis() + " : thread_" + id + " finish!");

24. }

25. });

26. taski.setDaemon(true);

27. executorService.submit(taski);

28. }

29. 
    

30. Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {

31. @Override

32. public void run() {

33. 
    

34. System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() + " No1 shutdown hooking...");

35. boolean shutdown = true;

36. try {

37. executorService.shutdown();

38. System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() + " shutdown signal got, wait threadPool finish.");

39. executorService.awaitTermination(1500, TimeUnit.SECONDS);

40. boolean done = false;

41. System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() + " all thread's done.");

42. }

43. catch (InterruptedException e) {

44. e.printStackTrace();

45. // 尝试再次关闭

46. if(!executorService.isTerminated()) {

47. executorService.shutdownNow();

48. }

49. }

50. System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() + " No1 shutdown done...");

51. }

52. }));

53. 
    

54. Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {

55. @Override

56. public void run() {

57. try {

58. System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() + " No2 shutdown hooking...");

59. Thread.sleep(1000);

60. }

61. catch (InterruptedException e) {

62. e.printStackTrace();

63. }

64. System.out.println(System.currentTimeMillis() + " : " + Thread.currentThread().getName() + " No2 shutdown done...");

65. }

66. }));

67. 
    

68. System.out.println("main method exit...");

69. System.exit(0);

70. }

71. }

运行结果如下：

很明显，确实是优雅了，虽然最后收到了一关闭信号，但是仍然保证了任务的处理完成。很棒吧！

那么，在实际应用中是如何体现优雅停机呢？

kill -15 pid

通过该命令发送一个关闭信号给到jvm, 然后就开始执行 Shutdown Hook 了，你可以做很多:

1. 关闭 socket 链接

2. 清理临时文件

3. 发送消息通知给订阅方，告知自己下线

4. 将自己将要被销毁的消息通知给子进程

5. 各种资源的释放 ...

而在平时工作中，我们不乏看到很多运维同学，是这么干的:

kill -9 pid

如果这么干的话，jvm也无法了,kill -9 相当于一次系统宕机，系统断电。这会给应用杀了个措手不及，没有留给应用任何反应的机会。

所以，无论如何是优雅不起来了。

要优雅，是代码和运维的结合！

其中，线程池的关闭方式为:

1. executorService.shutdown();

2. executorService.awaitTermination(1500, TimeUnit.SECONDS);

ThreadPoolExecutor 在 shutdown 之后会变成 SHUTDOWN 状态，无法接受新的任务，随后等待正在执行的任务执行完成。意味着，shutdown 只是发出一个命令，至于有没有关闭还是得看线程自己。

ThreadPoolExecutor 对于 shutdownNow 的处理则不太一样，方法执行之后变成 STOP 状态，并对执行中的线程调用 Thread.interrupt() 方法（但如果线程未处理中断，则不会有任何事发生），所以并不代表“立刻关闭”。

• shutdown() ：启动顺序关闭，其中执行先前提交的任务，但不接受新任务。如果已经关闭，则调用没有附加效果。此方法不等待先前提交的任务完成执行。

• shutdownNow()：尝试停止所有正在执行的任务，停止等待任务的处理，并返回正在等待执行的任务的列表。当从此方法返回时，这些任务将从任务队列中耗尽（删除）。此方法不等待主动执行的任务终止。

• executor.awaitTermination(this.awaitTerminationSeconds, TimeUnit.SECONDS)); 控制等待的时间，防止任务无限期的运行（前面已经强调过了，即使是 shutdownNow 也不能保证线程一定停止运行）。

注意:

• 虚拟机会对多个shutdownhook以未知的顺序调用，都执行完后再退出。

• 如果接收到 kill -15 pid 命令时，执行阻塞操作，可以做到等待任务执行完成之后再关闭 JVM。同时，也解释了一些应用执行 kill -15 pid 无法退出的问题，如:中断被阻塞了,或者hook运行了死循环代码。

实现原理:

Runtime.getRuntime().addShutdownHook(hook); // 添加钩子,开启优雅之路

// 具体流程如下：

1. /**

2. * Registers a new virtual-machine shutdown hook.

3. *

4. * @param hook

5. * An initialized but unstarted <tt>{@link Thread}</tt> object

6. *

7. * @throws IllegalArgumentException

8. * If the specified hook has already been registered,

9. * or if it can be determined that the hook is already running or

10. * has already been run

11. *

12. * @throws IllegalStateException

13. * If the virtual machine is already in the process

14. * of shutting down

15. *

16. * @throws SecurityException

17. * If a security manager is present and it denies

18. * <tt>{@link RuntimePermission}("shutdownHooks")</tt>

19. *

20. * @see #removeShutdownHook

21. * @see #halt(int)

22. * @see #exit(int)

23. * @since 1.3

24. */

25. public void addShutdownHook(Thread hook) {

26. SecurityManager sm = System.getSecurityManager();

27. if (sm != null) {

28. sm.checkPermission(new RuntimePermission("shutdownHooks"));

29. }

30. // 添加到 application 中

31. ApplicationShutdownHooks.add(hook);

32. }

33. 
    

34. // java.lang.ApplicationShutdownHooks.add(hook);

35. static synchronized void add(Thread hook) {

36. if(hooks == null)

37. throw new IllegalStateException("Shutdown in progress");

38. 
    

39. if (hook.isAlive())

40. throw new IllegalArgumentException("Hook already running");

41. 
    

42. if (hooks.containsKey(hook))

43. throw new IllegalArgumentException("Hook previously registered");

44. // hooks 以map类型保存, k->k 形式存储，保证每一个钩子都是独立的

45. hooks.put(hook, hook);

46. }

47. 
    

48. // java.lang.ApplicationShutdownHooks 会先注册一个静态块，添加一个任务到 Shutdown 中

49. /* The set of registered hooks */

50. private static IdentityHashMap<Thread, Thread> hooks;

51. static {

52. try {

53. Shutdown.add(1 /* shutdown hook invocation order */,

54. false /* not registered if shutdown in progress */,

55. new Runnable() {

56. public void run() {

57. // 即当该任务被调用时，调用自身的运行方法，使所有注册的 hook 运行起来

58. runHooks();

59. }

60. }

61. );

62. hooks = new IdentityHashMap<>();

63. } catch (IllegalStateException e) {

64. // application shutdown hooks cannot be added if

65. // shutdown is in progress.

66. hooks = null;

67. }

68. }

69. 
    

70. // runHooks 执行所有钩子线程,进行异步调用

71. /* Iterates over all application hooks creating a new thread for each

72. * to run in. Hooks are run concurrently and this method waits for

73. * them to finish.

74. */

75. static void runHooks() {

76. Collection<Thread> threads;

77. synchronized(ApplicationShutdownHooks.class) {

78. threads = hooks.keySet();

79. hooks = null;

80. }

81. 
    

82. for (Thread hook : threads) {

83. hook.start();

84. }

85. for (Thread hook : threads) {

86. try {

87. // 阻塞等待所有完成

88. hook.join();

89. } catch (InterruptedException x) { }

90. }

91. }

到现在为止，我们已经知道关闭钩子是如何执行的，但是，还不是知道，该钩子是何时触发？

1. // java.lang.Shutdown.add() 该方法会jvm主动调用，从而触发 后续钩子执行

2. /* Invoked by the JNI DestroyJavaVM procedure when the last non-daemon

3. * thread has finished. Unlike the exit method, this method does not

4. * actually halt the VM.

5. */

6. static void shutdown() {

7. synchronized (lock) {

8. switch (state) {

9. case RUNNING: /* Initiate shutdown */

10. state = HOOKS;

11. break;

12. case HOOKS: /* Stall and then return */

13. case FINALIZERS:

14. break;

15. }

16. }

17. synchronized (Shutdown.class) {

18. // 执行序列

19. sequence();

20. }

21. }

22. // 而 sequence() 则会调用 runHooks(), 调用自定义的钩子任务

23. private static void sequence() {

24. synchronized (lock) {

25. /* Guard against the possibility of a daemon thread invoking exit

26. * after DestroyJavaVM initiates the shutdown sequence

27. */

28. if (state != HOOKS) return;

29. }

30. runHooks();

31. boolean rfoe;

32. synchronized (lock) {

33. state = FINALIZERS;

34. rfoe = runFinalizersOnExit;

35. }

36. if (rfoe) runAllFinalizers();

37. }

38. 
    

39. // 执行钩子，此处最多允许注册 10 个钩子，且进行同步调用，当然这是最顶级的钩子，钩子下还可以添加钩子，可以任意添加n个

40. private static void runHooks() {

41. for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {

42. try {

43. Runnable hook;

44. synchronized (lock) {

45. // acquire the lock to make sure the hook registered during

46. // shutdown is visible here.

47. currentRunningHook = i;

48. hook = hooks[i];

49. }

50. // 同步调用注册的hook, 即 前面看到 ApplicationShutdownHooks.runHooks()

51. if (hook != null) hook.run();

52. } catch(Throwable t) {

53. if (t instanceof ThreadDeath) {

54. ThreadDeath td = (ThreadDeath)t;

55. throw td;

56. }

57. }

58. }

59. }

如此，整个关闭流程完美了。

简化为:

1. 注册流程(应用主动调用)：Runtime.addShutdownHook -> ApplicationShutdownHooks.add()/static -> java.lang.Shutdown.add()/shutdown()

2. 执行流程(jvm自动调用)：java.lang.Shutdown.shutdown()->sequence()->runHooks() -> ApplicationShutdownHooks.runHooks() -> hooks 最终