dubbo的优雅停机

2019独角兽企业重金招聘Python工程师标准>>>

  优雅停机主要用在服务版本迭代上线的过程中，比如我们发布了新的服务版本，经常性是直接替换线上正在跑的服务，这个时候如果在服务切换的过程中老的服务没有正常关闭的话，容易造成内存清理问题，所以优雅停机也是重要的一环。
Dubbo的优雅停机是依赖于JDK的ShutdownHook函数，下面先了解一下JDK的ShutdownHook函数会在哪些时候生效：

• 程序正常退出
• 程序中使用System.exit()退出JVM
• 系统发生OutofMemory异常
• 使用kill pid干掉JVM进程的时候（kill -9时候是不能触发ShutdownHook生效的）

Dubbo优雅停机代码解读

dubbo的优雅停机代码入口就在于AbstractConfig的静态代码块中：

static {
        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
            public void run() {
                if (logger.isInfoEnabled()) {
                    logger.info("Run shutdown hook now.");
                }
                ProtocolConfig.destroyAll();
            }
        }, "DubboShutdownHook"));
    }
    
    //在停机的时候往往要注意的是：此时服务器很大可能性既是consumer又是provider，所以要在两方面都进行一定的处理
    public static void destroyAll() {
        // 关闭所有注册中心，清空注册中心的内容。
        // 关闭zk连接，这时候consumer端从zk上已经找不到关闭的服务了
        // 取消所有的注册和订阅关系，作为consumer则不再监听数据变更，作为provider则简单断开于zk的连接
        AbstractRegistryFactory.destroyAll();
        ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);
        for (String protocolName : loader.getLoadedExtensions()) {
            try {
                Protocol protocol = loader.getLoadedExtension(protocolName);
                if (protocol != null) {
                    //关闭Server
                    protocol.destroy();
                }
            } catch (Throwable t) {
                logger.warn(t.getMessage(), t);
            }
        }
    }
    
    /**
     * 关闭所有已创建注册中心
     */
    public static void destroyAll() {
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Close all registries " + getRegistries());
        }
        // 锁定注册中心关闭过程，防止一个注册中心被多次关闭
        LOCK.lock();
        try {
            for (Registry registry : getRegistries()) {
                try {
                    //以zk注册中心为例讲解，zkRegistry->FailbackRegistry->AbstractRegistry
                    registry.destroy();
                } catch (Throwable e) {
                    LOGGER.error(e.getMessage(), e);
                }
            }
            REGISTRIES.clear();
        } finally {
            // 释放锁
            LOCK.unlock();
        }
    }
    
    //ZookeeperRegistry.destory() 
    //可以看到的是这一层关闭的核心就是关闭zkClient
    public void destroy() {
        super.destroy();
        try {
            zkClient.close();
        } catch (Exception e) {
            logger.warn("Failed to close zookeeper client " + getUrl() + ", cause: " + e.getMessage(), e);
        }
    }
    
    //FailbackRegistry.destory()
    //首先要明白FailbackRegistry的核心就在于失败重试，所以这一层的关闭只要关闭retryFuture就可以
    public void destroy() {
        super.destroy();
        try {
            retryFuture.cancel(true);
        } catch (Throwable t) {
            logger.warn(t.getMessage(), t);
        }
    }
    
    //AbstractRegistry.destory()
    //处理通用的destory逻辑
    public void destroy() {
        if (logger.isInfoEnabled()){
            logger.info("Destroy registry:" + getUrl());
        }
        //作为provider，取消所有的服务注册
        Set<URL> destroyRegistered = new HashSet<URL>(getRegistered());
        if (! destroyRegistered.isEmpty()) {
            for (URL url : new HashSet<URL>(getRegistered())) {
                if (url.getParameter(Constants.DYNAMIC_KEY, true)) {
                    try {
                        //从已注册的列表中移除该URL
                        unregister(url);
                        if (logger.isInfoEnabled()) {
                            logger.info("Destroy unregister url " + url);
                        }
                    } catch (Throwable t) {
                        logger.warn("Failed to unregister url " + url + " to registry " + getUrl() + " on destroy, cause: " + t.getMessage(), t);
                    }
                }
            }
        }
        //作为consumer，取消所有的订阅关系
        Map<URL, Set<NotifyListener>> destroySubscribed = new HashMap<URL, Set<NotifyListener>>(getSubscribed());
        if (! destroySubscribed.isEmpty()) {
            for (Map.Entry<URL, Set<NotifyListener>> entry : destroySubscribed.entrySet()) {
                URL url = entry.getKey();
                for (NotifyListener listener : entry.getValue()) {
                    try {
                        //将listener从订阅者对应的listener集合中移除（监听的服务变更将不再进行通知）
                        unsubscribe(url, listener);
                        if (logger.isInfoEnabled()) {
                            logger.info("Destroy unsubscribe url " + url);
                        }
                    } catch (Throwable t) {
                        logger.warn("Failed to unsubscribe url " + url + " to registry " + getUrl() + " on destroy, cause: " +t.getMessage(), t);
                    }
                }
            }
        }
    }

下面总结一下AbstractRegistryFactory.destroyAll()做的所有事情：

断开于zk的连接。 默认情况下服务端的dynamic为true，也就是dubbo自己管理服务的注册，所以这时候会在zk节点上创建临时的URL节点信息，在客户端与zk端开之后，zk监测到连接关闭，所以客户端创建的临时节点信息也会直接移除（zk临时节点的特性）。作为provider，这时候在zk节点上已经没有自己的信息了，所以这时候consumer理论上已经不会再看到该provider的信息了，也就是说不会有新的请求在过来，但是如果集群比较庞大的话，可能不止有一个zk节点，这时候可能依然会有请求过来。作为consumer，因为consumer在zk上注册的为持久节点，所以在连接断开时候并不会删除该节点，只是会移除对应的监听器。但是这里有一个容易忽略的问题就是，服务端注册的节点在zk上并不会删除，那么下次当consumer再次subscribe的时候依然后创建该节点，这时候因为该节点在上次停机的时候已经创建过了，重新创建就会抛异常了，这要怎么处理？哈哈
，Dubbo的做法是直接捕获NodeExistsException然后什么都不做，如果出现该异常了默认就是创建成功，只不过会再次重新注册监听器而已。

接下来就看一下Protocol.destory()，因为Protocol的实现类中主要分为两类，一类是RegistryProtoocl，另外一类是可扩展的Protocol（DubboProtocol）。

 

 

转载于:https://my.oschina.net/zhaolin/blog/2051889