深入理解Eureka自我保护机制（五）

为什么要有自我保护机制

众所周知，Eureka在CAP理论当中是属于AP ， 也就说当产生网络分区时，Eureka保证系统的可用性，但不保证系统里面数据的一致性， 举个例子。当发生网络分区的时候，Eureka-Server和client端的通信被终止，server端收不到大部分的client的续约，这个时候，如果直接将没有收到心跳的client端自动剔除，那么会将可用的client端剔除，这不符合AP理论，所以Eureka宁可保留也许已经宕机了的client端 ， 也不愿意将可以用的client端一起剔除。 从这一点上，也就保证了Eureka程序的健壮性，符合AP理论

重要变量

this.expectedNumberOfRenewsPerMin = count * 2;
this.numberOfRenewsPerMinThreshold =(int) (this.expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold());

expectedNumberOfRenewsPerMin ：每分钟最大的续约数量，由于客户端是每30秒续约一次，一分钟就是续约2次， count代表的是客户端数量所以这个变量的计算公式 ： 客户端数量*2 numberOfRenewsPerMinThreshold ： 每分钟最小续约数量， 使用expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold()。serverConfig.getRenewalPercentThreshold()的默认值为0.85 ， 也就是说每分钟的续约数量要大于85% 。

Eureka的自我保护机制，都是围绕这两个变量来实现的， 如果每分钟的续约数量小于numberOfRenewsPerMinThreshold ， 就会开启自动保护机制。

在此期间，不会再主动剔除任何一个客户端。

变量更新

Eureka-Server初始化，cancle主动下线， 客户端注册 ,定时器， 这四个场景会更新这两个变量

Eureka-Server初始化

protected void initEurekaServerContext() throws Exception {
   // ....省略N多代码
   // 服务刚刚启动的时候，去其他服务节点同步客户端的数量。
   int registryCount = this.registry.syncUp();
   // 这个方法里面计算expectedNumberOfRenewsPerMin的值
   this.registry.openForTraffic(this.applicationInfoManager, registryCount);
​
   // Register all monitoring statistics.
   EurekaMonitors.registerAllStats();
}
​
​
this.registry.openForTraffic(this.applicationInfoManager, registryCount);
​
@Override
public void openForTraffic(ApplicationInfoManager applicationInfoManager, int count) {
    // 此处初始化值，客户端数量*2 
    this.expectedNumberOfRenewsPerMin = count * 2;
    // serverConfig.getRenewalPercentThreshold() 默认为0.85
    this.numberOfRenewsPerMinThreshold =
            (int) (this.expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold());
    // ...省略N多代码
    // 开启定时清理过期客户端的定时器
    super.postInit();
}

cancle主动下线

@Override
public boolean cancel(final String appName, final String id,
                      final boolean isReplication) {
    if (super.cancel(appName, id, isReplication)) {
        replicateToPeers(Action.Cancel, appName, id, null, null, isReplication);
        synchronized (lock) {
            if (this.expectedNumberOfRenewsPerMin > 0) {
                // 重点在这里，，，，，主动下线的时候，需要去更新每分钟最大续约数，
                // 一个客户端的每30秒续约一次，一分钟就是续约两次，所以需要减2.
                this.expectedNumberOfRenewsPerMin = this.expectedNumberOfRenewsPerMin - 2;
                this.numberOfRenewsPerMinThreshold =
                        (int) (this.expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold());
            }
        }
        return true;
    }
    return false;
}

客户端注册

public void register(InstanceInfo registrant, int leaseDuration, boolean isReplication) {
    try {
        read.lock();
        // ....省略 N多代码
       
        if (existingLease != null && (existingLease.getHolder() != null)) {
            // ....省略 N多代码
        } else {
            
            synchronized (lock) {
                if (this.expectedNumberOfRenewsPerMin > 0) {
                    // 重点在这里， 注册一个客户端，一个客户端每分钟需要两次续约，所以这里加2 
                    this.expectedNumberOfRenewsPerMin = this.expectedNumberOfRenewsPerMin + 2;
                    this.numberOfRenewsPerMinThreshold =
                            (int) (this.expectedNumberOfRenewsPerMin * serverConfig.getRenewalPercentThreshold());
                }
            }
            logger.debug("No previous lease information found; it is new registration");
        }
        // ....省略 N多代码
    } finally {
        read.unlock();
    }
}

定时器

在Eureka-Server启动的时候，会进行初始化，执行路径如下：

DefaultEurekaServerContext 》@PostConstruct修饰的initialize()方法》init()

@Override
public void init(PeerEurekaNodes peerEurekaNodes) throws Exception {
    // .... 省略N多代码
    // 启动定时器
    scheduleRenewalThresholdUpdateTask();
    // .... 省略N多代码
}
​
​
private void scheduleRenewalThresholdUpdateTask() {
    timer.schedule(new TimerTask() {
                       @Override
                       public void run() {
                           updateRenewalThreshold();
                       }
                   }, serverConfig.getRenewalThresholdUpdateIntervalMs(),
            serverConfig.getRenewalThresholdUpdateIntervalMs());
}
​
​
private void updateRenewalThreshold() {
    try {
        Applications apps = eurekaClient.getApplications();
        // 计算有效的应用实例数量
        int count = 0;
        for (Application app : apps.getRegisteredApplications()) {
            for (InstanceInfo instance : app.getInstances()) {
                if (this.isRegisterable(instance)) {
                    ++count;
                }
            }
        }
        synchronized (lock) {
            // 重新计算值
            if ((count * 2) > (serverConfig.getRenewalPercentThreshold() * numberOfRenewsPerMinThreshold)
                    || (!this.isSelfPreservationModeEnabled())) {
                this.expectedNumberOfRenewsPerMin = count * 2;
                this.numberOfRenewsPerMinThreshold = (int) ((count * 2) * serverConfig.getRenewalPercentThreshold());
            }
        }
        logger.info("Current renewal threshold is : {}", numberOfRenewsPerMinThreshold);
    } catch (Throwable e) {
        logger.error("Cannot update renewal threshold", e);
    }
}

renewalThresholdUpdateIntervalMs : 默认为15分钟serverConfig.getRenewalPercentThreshold() * numberOfRenewsPerMinThreshold 这个地方有个这个比较，当前最小续约数0.85 ， 然后呢，count2 要大于他，这个意思，主要是为了防止开启自我保护机制之后，被定时器重新计算了expectedNumberOfRenewsPerMin 和numberOfRenewsPerMinThreshold 的值

自我保护机制

开启

定期清理任务的线程最终执行的是这个方法，这里就直接开始讲

public void evict(long additionalLeaseMs) {
    logger.debug("Running the evict task");
    // 是否需要开启自我保护机制，如果需要，那么直接RETURE， 不需要继续往下执行了
    if (!isLeaseExpirationEnabled()) {
        logger.debug("DS: lease expiration is currently disabled.");
        return;
    }
​
    // ..... 省略N多代码，。这下面主要是做服务自动下线的操作的
​
}
​
​
@Override
public boolean isLeaseExpirationEnabled() {
    // 是否开启自我保护机制，这是个配置，默认为true
    if (!isSelfPreservationModeEnabled()) {
       
        return true;
    }
    // 计算是否需要自我保护
    return numberOfRenewsPerMinThreshold > 0 && getNumOfRenewsInLastMin() > numberOfRenewsPerMinThreshold;
}

从上面可以导，判断是否开启自我保护机制，主要在于计算每分钟最小续约数的值， getNumOfRenewInLastMin()这个获取的

是每分钟的续约数量（每个客户端来续约的时候，都是会更新这个值得，每分钟重置一次，有线程去跑的）， 如果每分钟的

续约数量>最小续约数，则不需要开启自我保护机制， 如果是小于，那么就是需要开启， 所以当返回false的时候，就需要开启

自我保护机制了。

PS： 其实说白了，自我保护机制，就是在定时任务执行之前，判断每分钟的续约数量，然后决定是否继续执行下去。

因此Eureka Server的过期时间（默认60s） ,客户端的续约时间（默认30s） , 这个配置最好不要更改，如果更改的话

就会打破自我保护机制的规则。

解除

1.当服务的网络分区解除之后，客户端能够和服务进行交互时，在续约的时候，更新每分钟的续约数，当每分钟的续约数大于

85%时，则自动解除。

2.重启服务