本文来说下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 的值。

自我保护机制

一句话总结：某时刻某一个微服务不可以用了，eureka不会立刻清理，依旧会对该微服务的信息进行保存！

• 默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒）。但是当网络分区故障发生时，微服务与Eureka之间无法正常通行，以上行为可能变得非常危险了–因为微服务本身其实是健康的，此时本不应该注销这个服务。Eureka通过自我保护机制来解决这个问题–当EurekaServer节点在短时间内丢失过多客户端时（可能发生了网络分区故障），那么这个节点就会进入自我保护模式。一旦进入该模式，EurekaServer就会保护服务注册表中的信息，不再删除服务注册表中的数据(也就是不会注销任何微服务）。当网络故障恢复后，该EurekaServer节点会自动退出自我保护模式。
• 在自我保护模式中，EurekaServer会保护服务注册表中的信息，不再注销任何服务实例。当它收到的心跳数重新恢复到阈值以上时，该EurekaServer节点就会自动退出自我保护模式。它的设计哲学就是宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例。一句话：好死不如赖活着。
• 综上，自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务（健康的微服务和不健康的微服务都会保留），也不盲目注销任何健康的微服务。使用自我保护模式，可以让Eureka集群更加的健壮和稳定。
• 在SpringCloud中，可以使用eureka.server.enable-self-preservation=false禁用自我保护模式【不推荐关闭自我保护机制】

开启

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

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） , 这个配置最好不要更改，如果更改的话就会打破自我保护机制的规则。

解除

解除

• 当服务的网络分区解除之后，客户端能够和服务进行交互时，在续约的时候，更新每分钟的续约数，当每分钟的续约数大于85%时，则自动解除。
• 重启服务

本文小结

本文详细介绍了Eureka自我保护机制。

最后

以上就是温柔歌曲为你收集整理的Eureka自我保护机制为什么要有自我保护机制重要变量变量更新自我保护机制本文小结的全部内容，希望文章能够帮你解决Eureka自我保护机制为什么要有自我保护机制重要变量变量更新自我保护机制本文小结所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。