• 欢迎来到Compiler网站,如果对网站内容感兴趣或者帮助到你,请为文章点赞,谢谢!

spring cloud 服务注册之Eureka Server(五) – 服务剔除策略

Spring Cloud 奔跑的蜗牛 1个月前 (08-21) 38次浏览 已收录 0个评论
文章目录[隐藏]

Eureka Server本身在做服务注册时,客户端是否下线,是通过客户端向服务端发送心跳信息, 服务端一次来保证客户端处于UP状态。同时当客户端心跳发送失败时,这是服务端将通过自身的剔除策略,将处于DOWN状态下的服务从Registry中进行移除,保证服务可用性。

策略如何启用?

前面章节中,服务的启动过程中详细阐述了EurekaServer的启用过程, 其中有介绍到, 当EurekaServerBootstrap在执行initilize方法时,会启动evict定时任务,执行服务剔除操作,具体代码如下:

protected void postInit() {
        renewsLastMin.start();
        if (evictionTaskRef.get() != null) {
            evictionTaskRef.get().cancel();
        }
        evictionTaskRef.set(new EvictionTask());
        evictionTimer.schedule(evictionTaskRef.get(),
                serverConfig.getEvictionIntervalTimerInMs(),
                serverConfig.getEvictionIntervalTimerInMs());
    }

evict任务启动,则是通过postInit方法执行,方法很简单, 主要包含三个步骤:

  • 开启renewLasmin任务
  • 判断当前是否已经存在evict任务,存在则取消
  • 开启evict定时任务,每60秒执行一次(eureka.server.eviction.interval-timer-ms = 60)

任务做了什么?

spring cloud 服务注册之Eureka Server(五) – 服务剔除策略

以上流程图我觉得是比较清晰的表达了整个evict方法执行的详情过程, 对于Eureka来说,有一下需要注意的点:

  • 执行Evict的定时任务为60秒执行一次
  • Eureka Server在计算Instance是否过期的时候,并不是采用一刀切的方式,而是通过当前时间与上一次执行的时间算出差值,动态的匹配那些instance过期
  • 当过期的instance数量 > instance总数 * renewsThreshold 的值时,并不会一次性将所有的instance的剔除,而是采用了取最小值的剔除策略.

源码解读

其他的细节我们就不用看了,直接看evict方法是如何将instance做剔除操作的:

public void evict(long additionalLeaseMs) {
        logger.debug("Running the evict task");

        // 判断当前instance registry是否支持将Lease过期, 如果为false, 则结束执行,数据不会从map中剔除
        if (!isLeaseExpirationEnabled()) {
            logger.debug("DS: lease expiration is currently disabled.");
            return;
        }

        // We collect first all expired items, to evict them in random order. For large eviction sets,
        // if we do not that, we might wipe out whole apps before self preservation kicks in. By randomizing it,
        // the impact should be evenly distributed across all applications.
        List<Lease<InstanceInfo>> expiredLeases = new ArrayList<>();
        for (Entry<String, Map<String, Lease<InstanceInfo>>> groupEntry : registry.entrySet()) {
            Map<String, Lease<InstanceInfo>> leaseMap = groupEntry.getValue();
            if (leaseMap != null) {
                for (Entry<String, Lease<InstanceInfo>> leaseEntry : leaseMap.entrySet()) {
                    Lease<InstanceInfo> lease = leaseEntry.getValue();

                    // 判断当前lease是否过期的依据,主要是根据三个值计算: System.currentTimeMillis() > (lastUpdateTimestamp + duration + additionalLeaseMs)
                    // additianalLeaseMs则是根据当前时间 - 上一次执行evict的时间,的到的一个差值
                    // lastUpdateTimestamp主要是值当前Lease客户端心跳的时间
                    // duration主要为心跳的间隔时间
                    if (lease.isExpired(additionalLeaseMs) && lease.getHolder() != null) {
                        expiredLeases.add(lease);
                    }
                }
            }
        }

        // To compensate for GC pauses or drifting local time, we need to use current registry size as a base for
        // triggering self-preservation. Without that we would wipe out full registry.
        int registrySize = (int) getLocalRegistrySize();
        int registrySizeThreshold = (int) (registrySize * serverConfig.getRenewalPercentThreshold());
        int evictionLimit = registrySize - registrySizeThreshold;

        // 这里也是执行evict相关的关键点所在, 可能过期的expiredLease会大于evictionLimit信息,这时并不会将所有Lease全部过期, 而是取最小值
        int toEvict = Math.min(expiredLeases.size(), evictionLimit);
        if (toEvict > 0) {
            logger.info("Evicting {} items (expired={}, evictionLimit={})", toEvict, expiredLeases.size(), evictionLimit);

            Random random = new Random(System.currentTimeMillis());
            for (int i = 0; i < toEvict; i++) {
                // Pick a random item (Knuth shuffle algorithm)
                int next = i + random.nextInt(expiredLeases.size() - i);
                Collections.swap(expiredLeases, i, next);
                Lease<InstanceInfo> lease = expiredLeases.get(i);

                String appName = lease.getHolder().getAppName();
                String id = lease.getHolder().getId();
                EXPIRED.increment();
                logger.warn("DS: Registry: expired lease for {}/{}", appName, id);
                // 真正执行evict策略的方法
                internalCancel(appName, id, false);
            }
        }
    }

前面也讲过,我们Registry对象是spring自己的实现InstanceRegistry对象,因此,在这个扩展的过程中,提供了不一样的点,就是EurekaInstanceCanceledEvent事件的发送:

private void handleCancelation(String appName, String id, boolean isReplication) {
        log("cancel " + appName + ", serverId " + id + ", isReplication "
                + isReplication);
        publishEvent(new EurekaInstanceCanceledEvent(this, appName, id, isReplication));
    }

 

真正的执行剔除的方法的,还是在AbstractInstanceRegistry中进行执行, 源码如下:

protected boolean internalCancel(String appName, String id, boolean isReplication) {
        try { // 获取读锁 
            read.lock();
            CANCEL.increment(isReplication);
            // 获取appName在registry中注册的Lease信息 
            Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
            Lease<InstanceInfo> leaseToCancel = null;
            if (gMap != null) {
                // 如果实例存在,则删除当前过期的实例 
                leaseToCancel = gMap.remove(id);
            }
            synchronized (recentCanceledQueue) {
                // 将伤处的Instance信息存入到queue中 
                recentCanceledQueue.add(new Pair<Long, String>(System.currentTimeMillis(), appName + "(" + id + ")"));
            }
            // 移除当前实例的overridenInstanceStatus信息 
            InstanceStatus instanceStatus = overriddenInstanceStatusMap.remove(id);
            if (instanceStatus != null) {
                logger.debug("Removed instance id {} from the overridden map which has value {}", id, instanceStatus.name());
            }
            // 如果当前实例的信息不存在时,直接返回 
            if (leaseToCancel == null) {
                CANCEL_NOT_FOUND.increment(isReplication);
                logger.warn("DS: Registry: cancel failed because Lease is not registered for: {}/{}", appName, id);
                return false;
            } else {
                leaseToCancel.cancel();
                InstanceInfo instanceInfo = leaseToCancel.getHolder();
                String vip = null;
                String svip = null;
                // 如果实例信息存在,则将当前实例信息标记为删除 
                if (instanceInfo != null) {
                    instanceInfo.setActionType(ActionType.DELETED);
                    recentlyChangedQueue.add(new RecentlyChangedItem(leaseToCancel));
                    instanceInfo.setLastUpdatedTimestamp();
                    vip = instanceInfo.getVIPAddress();
                    svip = instanceInfo.getSecureVipAddress();
                }
                // 过期responseCache中的readWriteCacheMap中的实例信息 
                invalidateCache(appName, vip, svip);
                logger.info("Cancelled instance {}/{} (replication={})", appName, id, isReplication);
                return true;
            }
        } finally {
            read.unlock();
        }
    }

至此,关于Eureka Server中关键的流程信息已经介绍完毕,如果大家对文章有好的意见或者疑问,都可以在评论区留言。


Compiler编程笔记 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权
转载请注明原文链接:spring cloud 服务注册之Eureka Server(五) – 服务剔除策略
喜欢 (8)
[阳光路上]
分享 (0)
发表我的评论
取消评论
表情 贴图 加粗 删除线 居中 斜体 签到

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址