一、背景

对于任何一个线上应用，如何在服务更新部署过程中保证客户端无感知是开发者必须要解决的问题，即从应用停止到重启恢复服务这个阶段不能影响正常的业务请求。理想条件下，在没有请求的时候再进行更新是最安全可靠的。然而互联网应用必须要保证可用性，因此在技术层面上优化应用更新流程来保证服务在更新时无损是必要的。
传统的解决方式是通过将应用更新流程划分为手工摘流量、停应用、更新重启三个步骤，由人工操作实现客户端对更新无感知。这种方式简单而高效，但是限制很多：不仅需要使用借助网关的支持来摘流量，还需要在停应用前人工判断来保证在途请求已经处理完毕。这种需要人工介入的方式运维复杂度较高，只能适用规模较小的应用，无法在大规模系统上使用。
因此，如果能在容器/框架级别提供某种自动化机制，来自动进行摘流量并确保处理完已经到达的请求，不仅能保证业务不受更新影响，还可以极大的提升更新应用时的运维效率。
这个机制也就是优雅停机，目前tomcat、undertow/dubbo等容器/框架都有提供相关实现。下面给出一些正式的定义：优雅停机是指在停止应用时，执行的一系列保证应用正常关闭的操作。这些操作往往包括等待已有请求执行完成、关闭线程、关闭连接和释放资源等。优雅停机可以避免非正常关闭程序可能造成的数据异常或丢失、应用异常等问题。优雅停机本质上是JVM即将关闭前执行的一些额外的处理代码。

二、适用场景

1）JVM主动关闭（System.exit(int)）
2）JVM由于资源问题退出（OOM）
3）应用程序接收到SIGTERM或SIGINT信号

三、配置方式

1）服务的优雅停机
在dubbo中优雅停机是默认开启的，停机等待时间是10ms。可以通过配置dubbo.service.shutdown.wait来修改等待时间
2）容器的优雅停机
当使用org.apache.dubbo.container.Main这种容器方式来使用 Dubbo 时，也可以通过配置dubbo.shutdown.hook为true来开启优雅停机。

四、流程

Provider在接收到停机指令后：
1）从注册中心上注销所有服务；
2）从配置中心取消监听动态配置；
3）向所有连接的客户端发送只读事件，停止接收新请求；
4）等待一段时间以处理已到达的请求，然后关闭请求处理线程池；
5）断开所有客户端连接。

Consumer在接收到停机指令后：
1）拒绝新到请求，直接返回调用异常；
2）等待当前已发送请求执行完毕，如果响应超时则强制关闭连接。
3）当使用容器方式运行 Dubbo 时，在容器准备退出前，可进行一系列的资源释放和清理工。
例如使用 SpringContainer时，Dubbo 的ShutdownHook线程会执行ApplicationContext的stop和close方法，保证 Bean的生命周期完整。

五、时序图

dubbo之优雅停机原理 - 图1

六、源码分析

dubbo的优雅停机是通过JVM的ShutdownHook钩子函数完成的。入口在AbstractConfig类中。
1、AbstractConfig

  1. static {
  2.     //AbstractConfig是ServiceConfig和ReferenceConfig，所以无论是提供者还是消费者，启动时都会执行以下代码
  3.     LEGACY_PROPERTIES.put("dubbo.protocol.name", "dubbo.service.protocol");
  4.     LEGACY_PROPERTIES.put("dubbo.protocol.host", "dubbo.service.server.host");
  5.     LEGACY_PROPERTIES.put("dubbo.protocol.port", "dubbo.service.server.port");
  6.     LEGACY_PROPERTIES.put("dubbo.protocol.threads", "dubbo.service.max.thread.pool.size");
  7.     LEGACY_PROPERTIES.put("dubbo.consumer.timeout", "dubbo.service.invoke.timeout");
  8.     LEGACY_PROPERTIES.put("dubbo.consumer.retries", "dubbo.service.max.retry.providers");
  9.     LEGACY_PROPERTIES.put("dubbo.consumer.check", "dubbo.service.allow.no.provider");
  10.    LEGACY_PROPERTIES.put("dubbo.service.url", "dubbo.service.address");
  11.    //钩子，优雅关机必备
  12.    DubboShutdownHook.getDubboShutdownHook().register();
  13. }

2、DubboShutdownHook

  1. public class DubboShutdownHook extends Thread {
  2.     public void run() {
  3.         if (logger.isInfoEnabled()) {
  4.             logger.info("Run shutdown hook now.");
  5.         }
  6.         //应用关闭时，会执行钩子的run方法
  7.         doDestroy();
  8.     }
  10.    //Destroy all the resources, including registries and protocols.
  11.    public void doDestroy() {
  12.         if (!destroyed.compareAndSet(false, true)) {
  13.             return;
  14.         }
  15.         //1）删除应用本身在注册中心的服务，2）取消应用订阅的服务信息
  16.         //详情参见第3、4目录源码分析
  17.         AbstractRegistryFactory.destroyAll();
  18.         //1）向所有消费端发送只读事件，告诉它们服务要关闭了，它们只能够从通道中读取未读完的数据
  19.         //2）关闭
  20.         //详情参见第5、7目录源码分析
  21.         destroyProtocols();
  22.    }
  24.    //Destroy all the protocols
  25.    private void destroyProtocols() {
  26.         ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);
  27.         //loader.getLoadedExtensions()将会获取三个Protocol实例，分别是DubbboProtocol、InjvmProtocol、
  28.         //RegistryProtocol，但这些实例都被包装了。
  29.         for (String protocolName : loader.getLoadedExtensions()) {
  30.             try {
  31.                 Protocol protocol = loader.getLoadedExtension(protocolName);
  32.                 if (protocol != null) {
  33.                     protocol.destroy();
  34.                 }
  35.             } catch (Throwable t) {
  36.                 logger.warn(t.getMessage(), t);
  37.             }
  38.         }
  39.     }
  40. }

3、AbstractRegistryFactory

  1. public static void destroyAll() {
  2.     //优秀的中间件/框架在核心步骤都会打日志，启应用如果有问题，多看启动日志
  3.     if (LOGGER.isInfoEnabled()) {
  4.         LOGGER.info("Close all registries " + getRegistries());
  5.     }
  6.     //上锁
  7.     LOCK.lock();
  8.     try {
  9.          //getRegistries()获取所有的注册实例。应用向多少个注册中心注册，getRegistries便会获取多少个注册实例
  10.         //使用zookeeper的话，registry的实例就是ZookeeperRegistry
  11.         for (Registry registry : getRegistries()) {
  12.             try {
  13.                 registry.destroy();
  14.             } catch (Throwable e) {
  15.                 LOGGER.error(e.getMessage(), e);
  16.             }
  17.         }
  18.         REGISTRIES.clear();
  19.     } finally {
  20.         // Release the lock
  21.         LOCK.unlock();
  22.     }
  23. }

4、ZookeeperRegistry
看一下类关系图：
dubbo之优雅停机原理 - 图2

  1. public class ZookeeperRegistry extends FailbackRegistry {
  2.     public void destroy() { 
  3.         //super指FailbackRegistry 
  4.         super.destroy();
  5.         try {
  6.             //zk客户端关闭
  7.             zkClient.close();
  8.         } catch (Exception e) {
  9.             logger.warn("Failed to close zookeeper client " + getUrl() + ", cause: " + e.getMessage(), e);
  10.         }
  11.     }
  13.     public void doUnregister(URL url) {
  14.         try {
  15.             //删除zk上注册的服务节点
  16.             zkClient.delete(toUrlPath(url));
  17.         } catch (Throwable e) {
  18.             throw new RpcException("Failed to unregister " + url + " to zookeeper " + getUrl() + ", cause: " + e.getMessage(), e);
  19.         }
  20.     }
  22.     public void doUnsubscribe(URL url, NotifyListener listener) {
  23.         ConcurrentMap<NotifyListener, ChildListener> listeners = zkListeners.get(url);
  24.         if (listeners != null) {
  25.             ChildListener zkListener = listeners.get(listener);
  26.             if (zkListener != null) {
  27.                 if (ANY_VALUE.equals(url.getServiceInterface())) {
  28.                     String root = toRootPath();
  29.                     zkClient.removeChildListener(root, zkListener);
  30.                 } else {
  31.                     for (String path : toCategoriesPath(url)) {
  32.                         zkClient.removeChildListener(path, zkListener);
  33.                     }
  34.                 }
  35.             }
  36.         }
  37.     }
  38. }
  40. public abstract class FailbackRegistry extends AbstractRegistry {
  41.     public void destroy() {
  42.         super.destroy();
  43.         retryTimer.stop();
  44.     }
  46.     public void unregister(URL url) {
  47.         super.unregister(url);
  48.         removeFailedRegistered(url);
  49.         removeFailedUnregistered(url);
  50.         try {
  51.             // Sending a cancellation request to the server side
  52.             doUnregister(url);
  53.         } catch (Exception e) {
  54.             Throwable t = e;
  55.             // If the startup detection is opened, the Exception is thrown directly.
  56.             boolean check = getUrl().getParameter(Constants.CHECK_KEY, true) && url.getParameter(Constants.CHECK_KEY, true)
  57.                     && !CONSUMER_PROTOCOL.equals(url.getProtocol());
  58.             boolean skipFailback = t instanceof SkipFailbackWrapperException;
  59.             if (check || skipFailback) {
  60.                 if (skipFailback) {
  61.                     t = t.getCause();
  62.                 }
  63.                 throw new IllegalStateException("Failed to unregister " + url + " to registry " + getUrl().getAddress() + ", cause: " + t.getMessage(), t);
  64.             } else {
  65.                 logger.error("Failed to unregister " + url + ", waiting for retry, cause: " + t.getMessage(), t);
  66.             }
  67.             // Record a failed registration request to a failed list, retry regularly
  68.             addFailedUnregistered(url);
  69.         }
  70.     }
  72.     public void unsubscribe(URL url, NotifyListener listener) {
  73.         super.unsubscribe(url, listener);
  74.         removeFailedSubscribed(url, listener);
  75.         try {
  76.             doUnsubscribe(url, listener);
  77.         } catch (Exception e) {
  78.             Throwable t = e;
  79.             // If the startup detection is opened, the Exception is thrown directly.
  80.             boolean check = getUrl().getParameter(Constants.CHECK_KEY, true) && url.getParameter(Constants.CHECK_KEY, true);
  81.             boolean skipFailback = t instanceof SkipFailbackWrapperException;
  82.             if (check || skipFailback) {
  83.                 if (skipFailback) {
  84.                     t = t.getCause();
  85.                 }
  86.                 throw new IllegalStateException("Failed to unsubscribe " + url + " to registry " + getUrl().getAddress() + ", cause: " + t.getMessage(), t);
  87.             } else {
  88.                 logger.error("Failed to unsubscribe " + url + ", waiting for retry, cause: " + t.getMessage(), t);
  89.             }
  90.             // Record a failed registration request to a failed list, retry regularly
  91.             addFailedUnsubscribed(url, listener);
  92.         }
  93.     }
  94. }
  96. public abstract class AbstractRegistry implements Registry {
  97.     ...
  98.     public void destroy() {
  99.         if (logger.isInfoEnabled()) {
  100.             logger.info("Destroy registry:" + getUrl());
  101.         }
  102.         Set<URL> destroyRegistered = new HashSet<>(getRegistered());
  103.         if (!destroyRegistered.isEmpty()) {
  104.             //遍历注册的url信息
  105.             for (URL url : new HashSet<>(getRegistered())) {
  106.                 if (url.getParameter(DYNAMIC_KEY, true)) {
  107.                     try {
  108.                         //取消在注册中心注册的服务，如zk，则是删除服务节点
  109.                         unregister(url);
  110.                         if (logger.isInfoEnabled()) {
  111.                             logger.info("Destroy unregister url " + url);
  112.                         }
  113.                     } catch (Throwable t) {
  114.                         logger.warn("Failed to unregister url " + url + " to registry " + getUrl() + " on destroy, cause: " + t.getMessage(), t);
  115.                     }
  116.                 }
  117.             }
  118.         }
  119.         Map<URL, Set<NotifyListener>> destroySubscribed = new HashMap<>(getSubscribed());
  120.         if (!destroySubscribed.isEmpty()) {
  121.             for (Map.Entry<URL, Set<NotifyListener>> entry : destroySubscribed.entrySet()) {
  122.                 URL url = entry.getKey();
  123.                 for (NotifyListener listener : entry.getValue()) {
  124.                     try {
  125.                         //取消监听，本服务不在监听zk上的节点的变化
  126.                         unsubscribe(url, listener);
  127.                         if (logger.isInfoEnabled()) {
  128.                             logger.info("Destroy unsubscribe url " + url);
  129.                         }
  130.                     } catch (Throwable t) {
  131.                         logger.warn("Failed to unsubscribe url " + url + " to registry " + getUrl() + " on destroy, cause: " + t.getMessage(), t);
  132.                     }
  133.                 }
  134.             }
  135.         }
  136.     }
  137. }

5、DubboProtocol实例：
调用链如下，根据”dubbo”获取到的实际上是包装类，层层包装，层层调用
dubbo之优雅停机原理 - 图3

  1. public class ProtocolListenerWrapper implements Protocol {
  2.     public void destroy() {
  3.         //protocol指QosProtocolWrapper 
  4.         protocol.destroy();
  5.     }
  6. }
  8. public class QosProtocolWrapper implements Protocol {
  9.      public void destroy() {
  10.         //protocol指QosProtocolWrapper 
  11.         protocol.destroy();
  12.         stopServer();
  13.     }
  14. }    
  16. public class ProtocolFilterWrapper implements Protocol {
  17.     public void destroy() {
  18.         //protocol指DubboProtocol
  19.         protocol.destroy();
  20.     }
  21. }
  23. public class DubboProtocol extends AbstractProtocol {
  24.     public void destroy() {
  25.         for (String key : new ArrayList<>(serverMap.keySet())) {
  26.                    //server就是HeaderExchangeServer，就是远程发布服务时，DubboProtocol开启端口监听时启动的
  27.                    //服务，最终是调用NettyServer（使用netty通信协议的话）  
  28.             ExchangeServer server = serverMap.remove(key);
  29.             if (server == null) {
  30.                 continue;
  31.             }
  32.             ...
  33.                    //调用HeaderExchangeServer的close方法   
  34.             server.close(ConfigurationUtils.getServerShutdownTimeout());
  35.             ...
  36.         }
  37.         for (String key : new ArrayList<>(referenceClientMap.keySet())) {
  38.             List<ReferenceCountExchangeClient> clients = referenceClientMap.remove(key);
  39.             if (CollectionUtils.isEmpty(clients)) {
  40.                 continue;
  41.             }
  42.             for (ReferenceCountExchangeClient client : clients) {
  43.                 closeReferenceCountExchangeClient(client);
  44.             }
  45.         }
  46.         stubServiceMethodsMap.clear();
  47.            //super指AbstractProtocol
  48.         super.destroy();
  49.     }
  50. }
  52. public abstract class AbstractProtocol implements Protocol {
  54.     public void destroy() {
  55.         //1、遍历移除invokers缓存中的invoker实例
  56.         //2、遍历调用invoker实例的destroy方法，其实是空方法，目前没有实际处理逻辑
  57.         for (Invoker<?> invoker : invokers) {
  58.             if (invoker != null) {
  59.                 invokers.remove(invoker);
  60.                 try {
  61.                     if (logger.isInfoEnabled()) {
  62.                         logger.info("Destroy reference: " + invoker.getUrl());
  63.                     }
  64.                     invoker.destroy();
  65.                 } catch (Throwable t) {
  66.                     logger.warn(t.getMessage(), t);
  67.                 }
  68.             }
  69.         }
  70.         //1、遍历移除AbstractProtocol.exporterMap缓存中的exporter实例
  71.         //2、遍历移除DubboExporter.exporterMap缓存中的exporter实例
  72.         for (String key : new ArrayList<String>(exporterMap.keySet())) {
  73.             Exporter<?> exporter = exporterMap.remove(key);
  74.             if (exporter != null) {
  75.                 try {
  76.                     if (logger.isInfoEnabled()) {
  77.                         logger.info("Unexport service: " + exporter.getInvoker().getUrl());
  78.                     }
  79.                     exporter.unexport();
  80.                 } catch (Throwable t) {
  81.                     logger.warn(t.getMessage(), t);
  82.                 }
  83.             }
  84.         }
  85.     }
  86. }

6、HeaderExchangeServer：

  1. public class HeaderExchangeServer implements ExchangeServer {
  2.     public void close(final int timeout) {
  3.         //将关闭的标识置为true
  4.         startClose();
  5.         if (timeout > 0) {
  6.             final long max = (long) timeout;
  7.             final long start = System.currentTimeMillis();
  8.             if (getUrl().getParameter(Constants.CHANNEL_SEND_READONLYEVENT_KEY, true)) {
  9.                  //向所有连接的通道发送只读事件，告诉消费者服务即将关闭，只能从通道读取为未读完的数据
  10.                 //？？猜测：当消费者收到该事件时，将进行中的任务处理完后，将会关闭与该服务提供者的通道，断开连接
  11.                 sendChannelReadOnlyEvent();
  12.             }
  13.             //如果还有通道是连接状态，并且未超时，则sleep 10毫秒
  14.             while (HeaderExchangeServer.this.isRunning() && System.currentTimeMillis() - start < max) {
  15.                 try {
  16.                     Thread.sleep(10);
  17.                 } catch (InterruptedException e) {
  18.                     logger.warn(e.getMessage(), e);
  19.                 }
  20.             }
  21.         }
  22.         //这一步是调用closeTimerTask定时任务，但它的实例是null，根本不会执行。所以不明白这个功能。
  23.         doClose();
  24.         //server值NettyServer
  25.         server.close(timeout);
  26.     }
  27. }
  29. public class NettyServer extends AbstractServer implements Server {
  30.     protected void doClose() throws Throwable {
  31.         try {
  32.             if (channel != null) {
  33.                 //关闭netty的boss组负责连接的通道。这个通道关闭之后，不会再有新的连接进来。
  34.                 channel.close();
  35.             }
  36.         } catch (Throwable e) {
  37.             logger.warn(e.getMessage(), e);
  38.         }
  39.         try {
  40.             //遍历关闭netty worker线程组的通道，worker组的通道通常负责读、写事件的处理
  41.             Collection<org.apache.dubbo.remoting.Channel> channels = getChannels();
  42.             if (channels != null && channels.size() > 0) {
  43.                 for (org.apache.dubbo.remoting.Channel channel : channels) {
  44.                     try {
  45.                         channel.close();
  46.                     } catch (Throwable e) {
  47.                         logger.warn(e.getMessage(), e);
  48.                     }
  49.                 }
  50.             }
  51.         } catch (Throwable e) {
  52.             logger.warn(e.getMessage(), e);
  53.         }
  54.         try {
  55.             //优雅关闭boss线程组、worker线程组
  56.             if (bootstrap != null) {
  57.                 bossGroup.shutdownGracefully();
  58.                 workerGroup.shutdownGracefully();
  59.             }
  60.         } catch (Throwable e) {
  61.             logger.warn(e.getMessage(), e);
  62.         }
  63.         try {
  64.             if (channels != null) {
  65.                 channels.clear();
  66.             }
  67.         } catch (Throwable e) {
  68.             logger.warn(e.getMessage(), e);
  69.         }
  70.     }
  71. }
  73. public abstract class AbstractServer extends AbstractEndpoint implements Server {
  74.     public void close() {
  75.         //在经过优雅关闭线程池后，立马关闭线程池，这种关闭比较粗暴。但通常在超时时间内（10s），
  76.         //线程池的任务都能够处理完，所以也不会造成数据问题、程序异常问题。
  77.         ExecutorUtil.shutdownNow(executor, 100);
  78.         try {
  79.             super.close();
  80.         } catch (Throwable e) {
  81.             logger.warn(e.getMessage(), e);
  82.         }
  83.         try {
  84.             doClose();
  85.         } catch (Throwable e) {
  86.             logger.warn(e.getMessage(), e);
  87.         }
  88.     }
  90.     public void close(int timeout) {
  91.         //优雅关闭线程池，executor就是指dubbo线程池，是从DataStore中取出来的。
  92.         //线程池的关闭，需要研究一下
  93.         ExecutorUtil.gracefulShutdown(executor, timeout);
  94.         close();
  95.     }
  96. }

7、InjvmProtocol实例：
调用链如下，根据”injvm”获取到的实际上是包装类，层层包装，层层调用
dubbo之优雅停机原理 - 图4

  1. InjvmProtocol的destroy方法继承的是AbstractProtocol方法，参见DubboProtocol中对
  2. AbstractProtocol源码的分析

8、RegistryProtocol实例：
调用链如下，根据”injvm”获取到的实际上是包装类，层层包装，层层调用
dubbo之优雅停机原理 - 图5

  1. public class RegistryProtocol implements Protocol {
  2.     public void destroy() {
  3.         List<Exporter<?>> exporters = new ArrayList<Exporter<?>>(bounds.values());
  4.         //1）遍历移除bounds中的exporter实例  2）取消服务注册  3）取消zk服务监听
  5.         for (Exporter<?> exporter : exporters) {
  6.             exporter.unexport();
  7.         }
  8.         //清除bounds缓存
  9.         bounds.clear();
  10.        DynamicConfiguration.getDynamicConfiguration()removeListener(ApplicationModel.getApplication() + CONFIGURATORS_SUFFIX, providerConfigurationListener);
  11.     }
  12. }