你们的优雅停机真的优雅吗？

1.前言

emm，又又遇到问题啦，现有业务系统应用上线存在窗口期，不能满足正常任务迭代上线。在非窗口期上线容易导致数据库、mq、jsf等线程中断，进而导致需要手动修单问题。故而通过添加优雅停机功能进行优化，令其在上线前选择优雅停机后，会优先断掉新流量的涌入，并预留一定时间处理现存连接，最后完全下线，可有效扩大上线预留窗口时间并降低上线期间线程中断，进而降低手动修单。可是什么是优雅停机呢？为什么现有的系统技术没有原生的优雅停机机制呢？通过调研整理文章如下。

2.何为优雅停机？

• 优雅停机是指为确保应用关闭时，通知应用进程释放所占用的资源。
• 线程池，shutdown（不接受新任务等待处理完）还是shutdownNow（调用Thread.interrupt进行中断）。
• socket链接，比如：netty、jmq、fmq。（需要着重处理）
• 告知注册中心快速下线，比如jsf。（需要着重处理）
• 清理临时文件。
• 各种堆内堆外内存释放。
总之，进程强行终止会带来数据丢失或者终端无法恢复到正常状态，在分布式环境下可能导致数据不一致的情况。
3.导致优雅停机不优雅的元凶之-kill命令

• kill指令
◦ kill -15 ：kill指令默认就是-15，知识发送一个SIGTERM信号通知进程终止，由进程自行决定怎么做，即进程不一定终止。一般不直接使用kill -15，不一定能够终止进程。
◦ kill -9：强制终止进程，进程会被立刻终止。kill -9 过于暴力，往往会出现事务执行、业务处理中断的情况，导致数据库中存在脏数据、系统中存在残留文件等情况。如果要使用kill -9，尽量先使用kill -15给进程一个处理善后的机会。该命令可以模拟一次系统宕机，系统断电等极端情况。
◦ kill -2：类似Ctrl + C退出，会先保存相关数据再终止进程。kill -2立刻终止正在执行的代码->保存数据->终止进程，只是在进程终止之前会保存相关数据，依然会出现事务执行、业务处理中断的情况，做不到优雅停机。
4.引申问题：jvm如何接受处理linux信号量的？

• 在jvm启动时就加载了自定义SingalHandler，关闭jvm时触发对应的handle。

1. public interface SignalHandler {
2.     SignalHandler SIG_DFL = new NativeSignalHandler(0L);
3.     SignalHandler SIG_IGN = new NativeSignalHandler(1L);
5.     void handle(Signal var1);
6. }
7. class Terminator {
8.     private static SignalHandler handler = null;
10.     Terminator() {
11.     }
12.     //jvm设置SignalHandler，在System.initializeSystemClass中触发
13.     static void setup() {
14.         if (handler == null) {
15.             SignalHandler var0 = new SignalHandler() {
16.                 public void handle(Signal var1) {
17.                     Shutdown.exit(var1.getNumber() + 128);//调用Shutdown.exit
18.                 }
19.             };
20.             handler = var0;
22.             try {
23.                 Signal.handle(new Signal("INT"), var0);//中断时
24.             } catch (IllegalArgumentException var3) {
25.                
26.             }
28.             try {
29.                 Signal.handle(new Signal("TERM"), var0);//终止时
30.             } catch (IllegalArgumentException var2) {
31.                
32.             }
34.         }
35.     }
36. }

复制代码

• Runtime.addShutdownHook。在了解Shutdown.exit之前，先看Runtime.getRuntime().addShutdownHook(shutdownHook)；则是为jvm中增加一个关闭的钩子，当jvm关闭的时候调用。

1. public class Runtime {
2.     public void addShutdownHook(Thread hook) {
3.         SecurityManager sm = System.getSecurityManager();
4.         if (sm != null) {
5.             sm.checkPermission(new RuntimePermission("shutdownHooks"));
6.         }
7.         ApplicationShutdownHooks.add(hook);
8.     }
9. }
10. class ApplicationShutdownHooks {
11.     /* The set of registered hooks */
12.     private static IdentityHashMap<Thread, Thread> hooks;
13.     static synchronized void add(Thread hook) {
14.         if(hooks == null)
15.             throw new IllegalStateException("Shutdown in progress");
17.         if (hook.isAlive())
18.             throw new IllegalArgumentException("Hook already running");
20.         if (hooks.containsKey(hook))
21.             throw new IllegalArgumentException("Hook previously registered");
23.         hooks.put(hook, hook);
24.     }
25. }
26. //它含数据结构和逻辑管理虚拟机关闭序列
27. class Shutdown {
28.     /* Shutdown 系列状态*/
29.     private static final int RUNNING = 0;
30.     private static final int HOOKS = 1;
31.     private static final int FINALIZERS = 2;
32.     private static int state = RUNNING;
33.     /* 是否应该运行所以finalizers来exit? */
34.     private static boolean runFinalizersOnExit = false;
35.     // 系统关闭钩子注册一个预定义的插槽.
36.     // 关闭钩子的列表如下:
37.     // (0) Console restore hook
38.     // (1) Application hooks
39.     // (2) DeleteOnExit hook
40.     private static final int MAX_SYSTEM_HOOKS = 10;
41.     private static final Runnable[] hooks = new Runnable[MAX_SYSTEM_HOOKS];
42.     // 当前运行关闭钩子的钩子的索引
43.     private static int currentRunningHook = 0;
44.     /* 前面的静态字段由这个锁保护 */
45.     private static class Lock { };
46.     private static Object lock = new Lock();
48.     /* 为native halt方法提供锁对象 */
49.     private static Object haltLock = new Lock();
51.     static void add(int slot, boolean registerShutdownInProgress, Runnable hook) {
52.         synchronized (lock) {
53.             if (hooks[slot] != null)
54.                 throw new InternalError("Shutdown hook at slot " + slot + " already registered");
56.             if (!registerShutdownInProgress) {//执行shutdown过程中不添加hook
57.                 if (state > RUNNING)//如果已经在执行shutdown操作不能添加hook
58.                     throw new IllegalStateException("Shutdown in progress");
59.             } else {//如果hooks已经执行完毕不能再添加hook。如果正在执行hooks时，添加的槽点小于当前执行的槽点位置也不能添加
60.                 if (state > HOOKS || (state == HOOKS && slot <= currentRunningHook))
61.                     throw new IllegalStateException("Shutdown in progress");
62.             }
64.             hooks[slot] = hook;
65.         }
66.     }
67.     /* 执行所有注册的hooks
68.      */
69.     private static void runHooks() {
70.         for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {
71.             try {
72.                 Runnable hook;
73.                 synchronized (lock) {
74.                     // acquire the lock to make sure the hook registered during
75.                     // shutdown is visible here.
76.                     currentRunningHook = i;
77.                     hook = hooks[i];
78.                 }
79.                 if (hook != null) hook.run();
80.             } catch(Throwable t) {
81.                 if (t instanceof ThreadDeath) {
82.                     ThreadDeath td = (ThreadDeath)t;
83.                     throw td;
84.                 }
85.             }
86.         }
87.     }
88.     /* 关闭JVM的操作
89.      */
90.     static void halt(int status) {
91.         synchronized (haltLock) {
92.             halt0(status);
93.         }
94.     }
95.     //JNI方法
96.     static native void halt0(int status);
97.     // shutdown的执行顺序：runHooks > runFinalizersOnExit
98.     private static void sequence() {
99.         synchronized (lock) {
100.             /* Guard against the possibility of a daemon thread invoking exit
101.              * after DestroyJavaVM initiates the shutdown sequence
102.              */
103.             if (state != HOOKS) return;
104.         }
105.         runHooks();
106.         boolean rfoe;
107.         synchronized (lock) {
108.             state = FINALIZERS;
109.             rfoe = runFinalizersOnExit;
110.         }
111.         if (rfoe) runAllFinalizers();
112.     }
113.     //Runtime.exit时执行，runHooks > runFinalizersOnExit > halt
114.     static void exit(int status) {
115.         boolean runMoreFinalizers = false;
116.         synchronized (lock) {
117.             if (status != 0) runFinalizersOnExit = false;
118.             switch (state) {
119.             case RUNNING:       /* Initiate shutdown */
120.                 state = HOOKS;
121.                 break;
122.             case HOOKS:         /* Stall and halt */
123.                 break;
124.             case FINALIZERS:
125.                 if (status != 0) {
126.                     /* Halt immediately on nonzero status */
127.                     halt(status);
128.                 } else {
129.                     /* Compatibility with old behavior:
130.                      * Run more finalizers and then halt
131.                      */
132.                     runMoreFinalizers = runFinalizersOnExit;
133.                 }
134.                 break;
135.             }
136.         }
137.         if (runMoreFinalizers) {
138.             runAllFinalizers();
139.             halt(status);
140.         }
141.         synchronized (Shutdown.class) {
142.             /* Synchronize on the class object, causing any other thread
143.              * that attempts to initiate shutdown to stall indefinitely
144.              */
145.             sequence();
146.             halt(status);
147.         }
148.     }
149.     //shutdown操作，与exit不同的是不做halt操作(关闭JVM)
150.     static void shutdown() {
151.         synchronized (lock) {
152.             switch (state) {
153.             case RUNNING:       /* Initiate shutdown */
154.                 state = HOOKS;
155.                 break;
156.             case HOOKS:         /* Stall and then return */
157.             case FINALIZERS:
158.                 break;
159.             }
160.         }
161.         synchronized (Shutdown.class) {
162.             sequence();
163.         }
164.     }
165. }

复制代码

5.Spring 中是如何实现优雅停机的？

• 以Spring3.2.12在spring中通过ContexClosedEvent事件来触发一些动作，主要通过LifecycleProcessor.onClose来做stopBeans。由此可见spring也基于jvm做了扩展。

1. public abstract class AbstractApplicationContext extends DefaultResourceLoader {
2.      public void registerShutdownHook() {
3.           if (this.shutdownHook == null) {
4.            // No shutdown hook registered yet.
5.                this.shutdownHook = new Thread() {
6.                     @Override
7.                     public void run() {
8.                          doClose();
9.                     }
10.                };
11.            Runtime.getRuntime().addShutdownHook(this.shutdownHook);
12.           }
13. }
14.      protected void doClose() {
15.           boolean actuallyClose;
16.           synchronized (this.activeMonitor) {
17.           actuallyClose = this.active && !this.closed;
18.           this.closed = true;
19.           }
21.           if (actuallyClose) {
22.                if (logger.isInfoEnabled()) {
23.                     logger.info("Closing " + this);
24.                }
26.                LiveBeansView.unregisterApplicationContext(this);
28.                try {
29.     //发布应用内的关闭事件
30.                     publishEvent(new ContextClosedEvent(this));
31.                }
32.                catch (Throwable ex) {
33.                     logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
34.                }
36.    // 停止所有的Lifecycle beans.
37.                try {
38.                     getLifecycleProcessor().onClose();
39.                }
40.                    catch (Throwable ex) {
41.                 logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
42.                }
44.    // 销毁spring 的 BeanFactory可能会缓存单例的 Bean.
45.                destroyBeans();
47.    // 关闭当前应用上下文（BeanFactory）
48.                closeBeanFactory();
50.    // 执行子类的关闭逻辑
51.                onClose();
53.                synchronized (this.activeMonitor) {
54.                     this.active = false;
55.                }
56.           }
57.      }
58. }
59. public interface LifecycleProcessor extends Lifecycle {
60. /**
61.   * Notification of context refresh, e.g. for auto-starting components.
62.   */
63.      void onRefresh();
65. /**
66.   * Notification of context close phase, e.g. for auto-stopping components.
67.   */
68.      void onClose();
69. }

复制代码

6.SpringBoot是如何做到优雅停机的？

• 优雅停机是springboot的特性之一，在收到终止信号后，不再接受、处理新请求，但会在终止进程之前预留一小段缓冲时间，已完成正在处理的请求。注：优雅停机需要在tomcat的9.0.33及其之后的版本才支持。
• springboot中有spring-boot-starter-actuator模块提供了一个restful接口，用于优雅停机。执行请求curl -X POST http://127.0.0.1:8088/shutdown。待关闭成功则返回提示。注：线上环境url需要设置权限，可配合spring-security使用火灾nginx限制内网访问``。

1. #启用shutdown
2. endpoints.shutdown.enabled=true
3. #禁用密码验证
4. endpoints.shutdown.sensitive=false
5. #可统一指定所有endpoints的路径
6. management.context-path=/manage
7. #指定管理端口和IP
8. management.port=8088
9. management.address=127.0.0.1
11. #开启shutdown的安全验证（spring-security）
12. endpoints.shutdown.sensitive=true
13. #验证用户名
14. security.user.name=admin
15. #验证密码
16. security.user.password=secret
17. #角色
18. management.security.role=SUPERUSER

复制代码

• springboot的shutdown通过调用AbstractApplicationContext.close实现的。

1. @ConfigurationProperties(
2.     prefix = "endpoints.shutdown"
3. )
4. public class ShutdownMvcEndpoint extends EndpointMvcAdapter {
5.     public ShutdownMvcEndpoint(ShutdownEndpoint delegate) {
6.         super(delegate);
7.     }
8.     //post请求
9.     @PostMapping(
10.         produces = {"application/vnd.spring-boot.actuator.v1+json", "application/json"}
11.     )
12.     @ResponseBody
13.     public Object invoke() {
14.         return !this.getDelegate().isEnabled() ? new ResponseEntity(Collections.singletonMap("message", "This endpoint is disabled"), HttpStatus.NOT_FOUND) : super.invoke();
15.     }
16. }
17. @ConfigurationProperties(
18.     prefix = "endpoints.shutdown"
19. )
20. public class ShutdownEndpoint extends AbstractEndpoint<Map<String, Object>> implements ApplicationContextAware {
21.     private static final Map<String, Object> NO_CONTEXT_MESSAGE = Collections.unmodifiableMap(Collections.singletonMap("message", "No context to shutdown."));
22.     private static final Map<String, Object> SHUTDOWN_MESSAGE = Collections.unmodifiableMap(Collections.singletonMap("message", "Shutting down, bye..."));
23.     private ConfigurableApplicationContext context;
25.     public ShutdownEndpoint() {
26.         super("shutdown", true, false);
27.     }
28.     //执行关闭
29.     public Map<String, Object> invoke() {
30.         if (this.context == null) {
31.             return NO_CONTEXT_MESSAGE;
32.         } else {
33.             boolean var6 = false;
35.             Map var1;
37.             class NamelessClass_1 implements Runnable {
38.                 NamelessClass_1() {
39.                 }
41.                 public void run() {
42.                     try {
43.                         Thread.sleep(500L);
44.                     } catch (InterruptedException var2) {
45.                         Thread.currentThread().interrupt();
46.                     }
47.                     //这个调用的就是AbstractApplicationContext.close
48.                     ShutdownEndpoint.this.context.close();
49.                 }
50.             }
52.             try {
53.                 var6 = true;
54.                 var1 = SHUTDOWN_MESSAGE;
55.                 var6 = false;
56.             } finally {
57.                 if (var6) {
58.                     Thread thread = new Thread(new NamelessClass_1());
59.                     thread.setContextClassLoader(this.getClass().getClassLoader());
60.                     thread.start();
61.                 }
62.             }
64.             Thread thread = new Thread(new NamelessClass_1());
65.             thread.setContextClassLoader(this.getClass().getClassLoader());
66.             thread.start();
67.             return var1;
68.         }
69.     }
70. }

复制代码

7.知识拓展之Tomcat和Spring的关系？

通过参与云工厂优雅停机重构发现Tomcat和Spring均存在问题，故而查询探究两者之间。
• Tomcat和jettey是HTTP服务器和Servlet容器，负责给类似Spring这种servlet提供一个运行的环境，其中：Http服务器与Servlet容器的功能界限是：可以把HTTP服务器想象成前台的接待，负责网络通信和解析请求，Servlet容器是业务部门，负责处理业务请求。
• Tomcat和Servlet作为Web服务器和Servlet容器的结合，可以接受网络http请求解析为Servlet规范的请求对象和响应对象。比如，HttpServletRequest对象是Tomcat提供的，Servlet是规范，Tomcat是实现规范的Servlet容器，SpringMVC是处理Servlet请求的应用，其中DispatcherServlet实现了Servlet接口，Tomcat负责加载和调用DispatcherServlet。同时，DispatcherServlet有自己的容器（SpringMVC）容器，这个容器负责管理SpringMVC相关的bean，比如Controler和ViewResolver等。同时，Spring中还有其他的Bean比如Service和DAO等，这些由全局的Spring IOC容器管理，因此，Spring有两个IOC容器。
• 如果只是使用spring(不包含springmvc)，那么是tomcat容器解析xml文件，通过反射实例化对应的类，根据这些servlet规范实现类，触发对应的代码处理逻辑，这个时候tomcat负责http报文的解析和servlet调度的工作。
• 如果使用spring mvc，那么tomcat只是解析http报文，然后将其转发给dispatchsetvlet，然后由springmvc根据其配置，实例对应的类，执行对应的逻辑，然后返回结果给dispatchservlet，最后由它转发给tomcat,由tomcat负责构建http报文数据。
8.实战演练

• mq（jmq、fmq）通过添加hook在停机时调用pause先停止该应用的消费，防止出现上线期间mq中线程池的线程中断的情况发生。

1. /**
2. * @ClassName ShutDownHook
3. * @Description
4. * @Date 2022/10/28 17:47
5. **/
6. @Component
7. @Slf4j
8. public class ShutDownHook {
10.     @Value("${shutdown.waitTime:10}")
11.     private int waitTime;
13.     @Resource
14.     com.jdjr.fmq.client.consumer.MessageConsumer fmqMessageConsumer;
16.     @Resource
17.     com.jd.jmq.client.consumer.MessageConsumer jmqMessageConsumer;
20.     @PreDestroy
21.     public void destroyHook() {
22.         try {
23.             log.info("ShutDownHook destroy");
25.             jmqMessageConsumer.pause();
26.             fmqMessageConsumer.pause();
28.             int i = 0;
29.             while (i < waitTime) {
30.                 try {
31.                     Thread.sleep(1000);
32.                     log.info("距离服务关停还有{}秒", waitTime - i++);
33.                 } catch (Throwable e) {
34.                     log.error("异常", e);
35.                 }
36.             }
38.         } catch (Throwable e) {
39.             log.error("异常", e);
40.         }
42.     }
43. }

复制代码

• 在优雅停机时需要先把jsf生产者下线，并预留一定时间消费完毕，行云部署有相关stop.sh脚本，项目中通过在shutdown中编写方法实现。
jsf启停分析：见京东内部cf文档；

1. @Component
2. @Lazy(value = false)
3. public class ShutDown implements ApplicationContextAware {
4.     private static Logger logger = LoggerFactory.getLogger(ShutDown.class);
6.     @Value("${shutdown.waitTime:60}")
7.     private int waitTime;
9.     @Resource
10.     com.jdjr.fmq.client.consumer.MessageConsumer fmqMessageConsumer;
12.     @PostConstruct
13.     public void init() {
14.         logger.info("ShutDownHook init");
15.     }
17.     private ApplicationContext applicationContext = null;
19.     @PreDestroy
20.     public void destroyHook() {
21.         try {
22.             logger.info("ShutDownHook destroy");
23.             destroyJsfProvider();
24.             fmqMessageConsumer.pause();
26.             int i = 0;
27.             while (i < waitTime) {
28.                 try {
29.                     Thread.sleep(1000);
30.                     logger.info("距离服务关停还有{}秒", waitTime - i++);
31.                 } catch (Throwable e) {
32.                     logger.error("异常", e);
33.                 }
34.             }
36.         } catch (Throwable e) {
37.             logger.error("异常", e);
38.         }
40.     }
41.     private void destroyJsfProvider() {
42.         logger.info("关闭所有JSF生产者");
43.         if (null != applicationContext) {
44.             String[] providerBeanNames = applicationContext.getBeanNamesForType(ProviderBean.class);
45.             for (String name : providerBeanNames) {
46.                 try {
47.                     logger.info("尝试关闭JSF生产者" + name);
48.                     ProviderBean bean=(ProviderBean)applicationContext.getBean(name);
49.                     bean.destroy();
50.                     logger.info("关闭JSF生产者" + name + "成功");
51.                 } catch (BeanCreationNotAllowedException re){
52.                     logger.error("JSF生产者" + name + "未初始化，忽略");
53.                 } catch (Exception e) {
54.                     logger.error("关闭JSF生产者失败", e);
55.                 }
56.             }
57.         }
58.         logger.info("所有JSF生产者已关闭");
59.     }
61.     @Override
62.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
63.         this.applicationContext = applicationContext;
64.         ((AbstractApplicationContext)applicationContext).registerShutdownHook();
65.     }
67. }

复制代码

• absfactory-base-custcenter应用优雅停机出现日志无法打印问题，排查定位发现问题如下：通过本地debug发现优雅停机先销毁logback日志打印线程，导致实际倒计时的日志无法打印。

1.    
2.     <context-param>
3.         <param-name>logbackDisableServletContainerInitializer</param-name>
4.         <param-value>true</param-value>
5.     </context-param>

复制代码

9.总结

现有的springboot内置Tomcat能通过配置参数达到优雅停机的效果。但是因为业务系统中的代码中存在多种技术交叉应用，针对Tomcat和springmvc不同的应用确实需要花费时间研究底层原理来编写相关类实现同springboot配置参数托管的效果。

作者：京东科技 宋慧超
来源：京东云开发者社区

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！