SpringCloud 源码系列（2）—— 注册中心 Eureka（中）

SpringCloud 源码系列（1）—— 注册中心 Eureka（上）

SpringCloud 源码系列（2）—— 注册中心 Eureka（中）

SpringCloud 源码系列（3）—— 注册中心 Eureka（下）

五、服务注册

1、实例信息注册器初始化

服务注册的代码位置不容易发现，我们看 DiscoveryClient 初始化调度任务的这个方法，这段代码会去初始化一个实例信息复制器 InstanceInfoReplicator，这个复制器就包含了实例的注册（明明是注册却叫 Replicator 感觉怪怪的）。

① DiscoveryClient 初始化调度器的流程

• 先基于 DiscoveryClient、InstanceInfo 构造 InstanceInfoReplicator，然后还有两个参数为实例信息复制间隔时间（默认30秒）、并发的数量（默认为2）。
• 创建了一个实例状态变更监听器，并注册到 ApplicationInfoManager。当实例状态变更时，就会触发这个监听器，并调用 InstanceInfoReplicator 的 onDemandUpdate 方法。
• 启动 InstanceInfoReplicator，默认延迟40秒，也就是说服务启动可能40秒之后才会注册到注册中心。

private void initScheduledTasks() {
    // 省略定时刷新注册表的任务...

    if (clientConfig.shouldRegisterWithEureka()) {
        // 省略定时心跳的任务...

        // 实例信息复制器，用于定时更新自己状态，并向注册中心注册
        instanceInfoReplicator = new InstanceInfoReplicator(
                this,
                instanceInfo,
                clientConfig.getInstanceInfoReplicationIntervalSeconds(),
                2); // burstSize

        // 实例状态变更的监听器
        statusChangeListener = new ApplicationInfoManager.StatusChangeListener() {
            @Override
            public String getId() {
                return "statusChangeListener";
            }

            @Override
            public void notify(StatusChangeEvent statusChangeEvent) {
                if (statusChangeEvent.getStatus() == InstanceStatus.DOWN) {
                    logger.error("Saw local status change event {}", statusChangeEvent);
                } else {
                    logger.info("Saw local status change event {}", statusChangeEvent);
                }
                instanceInfoReplicator.onDemandUpdate();
            }
        };

        // 向 ApplicationInfoManager 注册状态变更监听器
        if (clientConfig.shouldOnDemandUpdateStatusChange()) {
            applicationInfoManager.registerStatusChangeListener(statusChangeListener);
        }

        // 启动实例信息复制器，默认延迟时间40秒
        instanceInfoReplicator.start(clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
    } else {
        logger.info("Not registering with Eureka server per configuration");
    }
}

② InstanceInfoReplicator 的构造方法

• 创建了一个单线程的调度器
• 设置 started 为 false
• 创建了以分钟为单位的限流器，每分钟默认最多只能调度4次

InstanceInfoReplicator(DiscoveryClient discoveryClient, InstanceInfo instanceInfo, int replicationIntervalSeconds, int burstSize) {
    this.discoveryClient = discoveryClient;
    this.instanceInfo = instanceInfo;
    // 单线程的调度器
    this.scheduler = Executors.newScheduledThreadPool(1,
            new ThreadFactoryBuilder()
                    .setNameFormat("DiscoveryClient-InstanceInfoReplicator-%d")
                    .setDaemon(true)
                    .build());

    this.scheduledPeriodicRef = new AtomicReference<Future>();
    // started 设置为 false
    this.started = new AtomicBoolean(false);
    // 以分钟为单位的限流器
    this.rateLimiter = new RateLimiter(TimeUnit.MINUTES);
    // 间隔时间，默认为30秒
    this.replicationIntervalSeconds = replicationIntervalSeconds;
    this.burstSize = burstSize;
    // 允许每分钟更新的频率 60 * 2 / 30 = 4
    this.allowedRatePerMinute = 60 * this.burstSize / this.replicationIntervalSeconds;
    logger.info("InstanceInfoReplicator onDemand update allowed rate per min is {}", allowedRatePerMinute);
}

③ 启动 InstanceInfoReplicator

• 将 started 设置为 true，代表已经启动了
• 调用 instanceInfo.setIsDirty() 方法，将实例设置为 dirty=true，并更新了最后一次设置 dirty 的时间戳
• InstanceInfoReplicator 实现了 Runnable，它本身被当成任务来调度，然后延迟40秒开始调度当前任务，并将 Future 放到本地变量中

public void start(int initialDelayMs) {
    // 启动时 started 设置为 true
    if (started.compareAndSet(false, true)) {
        // 设置为 dirty，便于下一次心跳时同步到 eureka server
        instanceInfo.setIsDirty();
        // 延迟40秒后开始调度当前任务
        Future next = scheduler.schedule(this, initialDelayMs, TimeUnit.SECONDS);
        // 将 Future 放到本地变量中
        scheduledPeriodicRef.set(next);
    }
}

///////

public synchronized void setIsDirty() {
    isInstanceInfoDirty = true;
    lastDirtyTimestamp = System.currentTimeMillis();
}

2、客户端实例注册

① 实现注册的run方法

接着看 InstanceInfoReplicator 的 run 方法，这个方法就是完成注册的核心位置。

• 首先会更新实例的信息，如果有变更就会设置 dirty=true
• 如过是 dirty 的，就会调用 DiscoveryClient 的 register 方法注册实例
• 实例注册后，就把 dirty 设置为 false
• 最后在 finally 中继续下一次的调度，默认是每隔30秒调度一次，注意他这里是把调度结果 Future 放到本地变量中

public void run() {
    try {
        // 更新本地实例信息，如果实例信息有变更，则 dirty=true
        discoveryClient.refreshInstanceInfo();

        // 设置为 dirty 时的时间戳
        Long dirtyTimestamp = instanceInfo.isDirtyWithTime();
        if (dirtyTimestamp != null) {
            // 注册实例
            discoveryClient.register();
            // 设置 dirty=false
            instanceInfo.unsetIsDirty(dirtyTimestamp);
        }
    } catch (Throwable t) {
        logger.warn("There was a problem with the instance info replicator", t);
    } finally {
        // 30秒之后再调度
        Future next = scheduler.schedule(this, replicationIntervalSeconds, TimeUnit.SECONDS);
        scheduledPeriodicRef.set(next);
    }
}

② 实例信息刷新

再来细看下 refreshInstanceInfo 刷新实例信息的方法：

• 首先刷新了数据中心的信息
• 然后刷新续约信息，主要就是将 EurekaClientConfig 的续约配置与本地的续约配置做对比，如果变更了就重新创建续约信息，并设置实例为dirty。这种情况一般就是运行期间动态更新实例的配置，然后重新注册实例信息。
• 接着使用健康检查器检查实例健康状况，从 getHealthCheckHandler 这段代码进去不难发现，我们可以自定义健康检查器，例如当本地的一些资源未创建成功、某些核心线程池down了就认为实例不可用，这个时候就可以自定义健康检查器。如果没有自定义健康检查器，那就直接返回实例当前的状态。我们可以实现 HealthCheckHandler 接口自定义健康检查器。
• 最后就会调用 ApplicationInfoManager 的 setInstanceStatus 设置实例状态，会判断如果状态发生变更，就会发出状态变更的通知，这样就会触发前面定义的状态变更监听器，然后调用 InstanceInfoReplicator 的 onDemandUpdate 方法。

void refreshInstanceInfo() {
    // 如果有必要，就更新数据中心的信息
    applicationInfoManager.refreshDataCenterInfoIfRequired();
    // 如果有必要，就更新续约信息，比如动态更新了配置文件，这时就更新续约信息 LeaseInfo，并将实例设置为 dirty
    applicationInfoManager.refreshLeaseInfoIfRequired();

    InstanceStatus status;
    try {
        // 用监控检查器检查实例的状态
        status = getHealthCheckHandler().getStatus(instanceInfo.getStatus());
    } catch (Exception e) {
        logger.warn("Exception from healthcheckHandler.getStatus, setting status to DOWN", e);
        status = InstanceStatus.DOWN;
    }

    if (null != status) {
        // 设置实例状态，实例状态变了会触发状态变更的监听器
        applicationInfoManager.setInstanceStatus(status);
    }
}

/////////////////////////////////

public void refreshLeaseInfoIfRequired() {
    // 当前实例续约信息
    LeaseInfo leaseInfo = instanceInfo.getLeaseInfo();
    if (leaseInfo == null) {
        return;
    }
    // 从配置中获取续约信息
    int currentLeaseDuration = config.getLeaseExpirationDurationInSeconds();
    int currentLeaseRenewal = config.getLeaseRenewalIntervalInSeconds();
    // 如果续约信息变了，就重新创建续约信息，并设置实例为 dirty
    if (leaseInfo.getDurationInSecs() != currentLeaseDuration || leaseInfo.getRenewalIntervalInSecs() != currentLeaseRenewal) {
        LeaseInfo newLeaseInfo = LeaseInfo.Builder.newBuilder()
                .setRenewalIntervalInSecs(currentLeaseRenewal)
                .setDurationInSecs(currentLeaseDuration)
                .build();
        instanceInfo.setLeaseInfo(newLeaseInfo);
        instanceInfo.setIsDirty();
    }
}

/////////////////////////////////

public HealthCheckHandler getHealthCheckHandler() {
    HealthCheckHandler healthCheckHandler = this.healthCheckHandlerRef.get();
    if (healthCheckHandler == null) {
        // 可以自定义 HealthCheckHandler 实现健康检查
        if (null != healthCheckHandlerProvider) {
            healthCheckHandler = healthCheckHandlerProvider.get();
        } else if (null != healthCheckCallbackProvider) {
            // 可以自定义 HealthCheckCallback 实现健康检查，HealthCheckCallback 已过期，建议使用 HealthCheckHandler
            healthCheckHandler = new HealthCheckCallbackToHandlerBridge(healthCheckCallbackProvider.get());
        }

        if (null == healthCheckHandler) {
            // 没有自定义的就是用默认的桥接类
            healthCheckHandler = new HealthCheckCallbackToHandlerBridge(null);
        }
        this.healthCheckHandlerRef.compareAndSet(null, healthCheckHandler);
    }

    return this.healthCheckHandlerRef.get();
}

//////////////////////////////////////

public synchronized void setInstanceStatus(InstanceStatus status) {
    InstanceStatus next = instanceStatusMapper.map(status);
    if (next == null) {
        return;
    }

    // 如果状态变更了，才会返回之前的状态，然后触发状态变更监听器
    InstanceStatus prev = instanceInfo.setStatus(next);
    if (prev != null) {
        for (StatusChangeListener listener : listeners.values()) {
            try {
                listener.notify(new StatusChangeEvent(prev, next));
            } catch (Exception e) {
                logger.warn("failed to notify listener: {}", listener.getId(), e);
            }
        }
    }
}

③ 向 eureka server 注册

在 run 方法里调用了 discoveryClient.register() 方法实现了客户端实例向注册中心的注册，进入到 register 方法可以看到，他就是使用前面构造的 EurekaTransport 来发起远程调用。

一层层进去，很容易发现就是调用了 eureka-server 的 POST /apps/{appName} 接口，后面我们就从 eureka-core 中找这个接口就可以找到注册中心实现服务注册的入口了。

boolean register() throws Throwable {
    logger.info(PREFIX + "{}: registering service...", appPathIdentifier);
    EurekaHttpResponse<Void> httpResponse;
    try {
        // registrationClient => JerseyReplicationClient
        httpResponse = eurekaTransport.registrationClient.register(instanceInfo);
    } catch (Exception e) {
        logger.warn(PREFIX + "{} - registration failed {}", appPathIdentifier, e.getMessage(), e);
        throw e;
    }
    if (logger.isInfoEnabled()) {
        logger.info(PREFIX + "{} - registration status: {}", appPathIdentifier, httpResponse.getStatusCode());
    }
    return httpResponse.getStatusCode() == Status.NO_CONTENT.getStatusCode();
}

/////////////////////////////////

public EurekaHttpResponse<Void> register(InstanceInfo info) {
    // 调用的是 POST apps/{appName} 接口
    String urlPath = "apps/" + info.getAppName();
    ClientResponse response = null;
    try {
        Builder resourceBuilder = jerseyClient.resource(serviceUrl).path(urlPath).getRequestBuilder();
        addExtraHeaders(resourceBuilder);
        response = resourceBuilder
                .header("Accept-Encoding", "gzip")
                .type(MediaType.APPLICATION_JSON_TYPE)
                .accept(MediaType.APPLICATION_JSON)
                // post 方法
                .post(ClientResponse.class, info);
        return anEurekaHttpResponse(response.getStatus()).headers(headersOf(response)).build();
    } finally {
        if (logger.isDebugEnabled()) {
            logger.debug("Jersey HTTP POST {}/{} with instance {}; statusCode={}", serviceUrl, urlPath, info.getId(),
                    response == null ? "N/A" : response.getStatus());
        }
        if (response != null) {
            response.close();
        }
    }
}

④ 注册中心设置实例状态为已启动

再回想下注册中心的初始化流程，在最后调用 openForTraffic 方法时，最后也会调用 ApplicationInfoManager 的 setInstanceStatus 方法，将实例状态设置为已启动，这个时候就会触发客户端注册到注册中心的动作。

applicationInfoManager.setInstanceStatus(InstanceStatus.UP);

⑤ 完成监听实例变更的方法

状态变更器会调用 onDemandUpdate 方法来完成实例状态变更后的逻辑。

• 它这里一个是用到了限流器来限制每分钟这个方法只能被调用4次，即避免了频繁的注册行为
• 然后在调度时，它会从本地变量中取出上一次调度的 Future，如果任务还没执行完，它会直接取消掉
• 最后就是调用 run 方法，完成服务的注册

public boolean onDemandUpdate() {
    // 限流控制
    if (rateLimiter.acquire(burstSize, allowedRatePerMinute)) {
        if (!scheduler.isShutdown()) {
            scheduler.submit(new Runnable() {
                @Override
                public void run() {
                    logger.debug("Executing on-demand update of local InstanceInfo");

                    // 如果上一次的任务还没有执行完，直接取消掉，然后执行注册的任务
                    Future latestPeriodic = scheduledPeriodicRef.get();
                    if (latestPeriodic != null && !latestPeriodic.isDone()) {
                        logger.debug("Canceling the latest scheduled update, it will be rescheduled at the end of on demand update");
                        latestPeriodic.cancel(false);
                    }

                    InstanceInfoReplicator.this.run();
                }
            });
            return true;
        } else {
            logger.warn("Ignoring onDemand update due to stopped scheduler");
            return false;
        }
    } else {
        logger.warn("Ignoring onDemand update due to rate limiter");
        return false;
    }
}

⑥ 限流器

最后简单看下限流器 RateLimiter 的设计：

• 从它的注释中可以看出，eureka 的 RateLimiter 是基于令牌桶算法实现的限流器
• acquire 方法有两个参数：
  • burstSize：允许以突发方式进入系统的最大请求数
  • averageRate：设置的时间窗口内允许进入的请求数

/**
 * Rate limiter implementation is based on token bucket algorithm. There are two parameters:
 * <ul>
 * <li>
 *     burst size - maximum number of requests allowed into the system as a burst
 * </li>
 * <li>
 *     average rate - expected number of requests per second (RateLimiters using MINUTES is also supported)
 * </li>
 * </ul>
 *
 * @author Tomasz Bak
 */
public class RateLimiter {

    private final long rateToMsConversion;

    private final AtomicInteger consumedTokens = new AtomicInteger();
    private final AtomicLong lastRefillTime = new AtomicLong(0);

    @Deprecated
    public RateLimiter() {
        this(TimeUnit.SECONDS);
    }

    public RateLimiter(TimeUnit averageRateUnit) {
        switch (averageRateUnit) {
            case SECONDS:
                rateToMsConversion = 1000;
                break;
            case MINUTES:
                rateToMsConversion = 60 * 1000;
                break;
            default:
                throw new IllegalArgumentException("TimeUnit of " + averageRateUnit + " is not supported");
        }
    }

    public boolean acquire(int burstSize, long averageRate) {
        return acquire(burstSize, averageRate, System.currentTimeMillis());
    }

    public boolean acquire(int burstSize, long averageRate, long currentTimeMillis) {
        if (burstSize <= 0 || averageRate <= 0) { // Instead of throwing exception, we just let all the traffic go
            return true;
        }

        refillToken(burstSize, averageRate, currentTimeMillis);
        return consumeToken(burstSize);
    }

    private void refillToken(int burstSize, long averageRate, long currentTimeMillis) {
        // 上一次填充 token 的时间
        long refillTime = lastRefillTime.get();
        // 时间差
        long timeDelta = currentTimeMillis - refillTime;
        // 固定生成令牌的速率，即每分钟4次
        // 例如刚好间隔15秒进来一个请求，就是 15000 * 4 / 60000 = 1，newTokens 代表间隔了多少次，如果等于0，说明间隔不足15秒
        long newTokens = timeDelta * averageRate / rateToMsConversion;
        if (newTokens > 0) {
            long newRefillTime = refillTime == 0
                    ? currentTimeMillis
                    // 注意这里不是直接设置的当前时间戳，而是根据 newTokens 重新计算的，因为有可能同一周期内同时有多个请求进来，这样可以保持一个固定的周期
                    : refillTime + newTokens * rateToMsConversion / averageRate;
            if (lastRefillTime.compareAndSet(refillTime, newRefillTime)) {
                while (true) {
                    // 调整令牌的数量
                    int currentLevel = consumedTokens.get();
                    int adjustedLevel = Math.min(currentLevel, burstSize);
                    // currentLevel 可能为2，重置为了 0 或 1
                    int newLevel = (int) Math.max(0, adjustedLevel - newTokens);
                    if (consumedTokens.compareAndSet(currentLevel, newLevel)) {
                        return;
                    }
                }
            }
        }
    }

    private boolean consumeToken(int burstSize) {
        while (true) {
            int currentLevel = consumedTokens.get();
            // 突发数量为2，也就是允许15秒内最多有两次请求进来
            if (currentLevel >= burstSize) {
                return false;
            }
            if (consumedTokens.compareAndSet(currentLevel, currentLevel + 1)) {
                return true;
            }
        }
    }

    public void reset() {
        consumedTokens.set(0);
        lastRefillTime.set(0);
    }
}

3、Eureka Server 接收注册请求

① 找到实例注册的API入口

从前面的分析中，我们知道服务端注册的API是 POST /apps/{appName}，由于 eureka 是基于 jersey 来通信的，想找到API入口还是有点费劲的，至少没有 springmvc 那么容易。

先看 ApplicationsResource 这个类，可以找到 getApplicationResource 这个方法的路径是符合 /apps/{appName} 这个规则的。然后可以看到它里面创建了 ApplicationResource，再进入到这个类里面，就可以找到 @Post 标注的 addInstance 方法，这就是注册的入口了。可以看到它是调用了注册表的 register 方法来注册实例的。

@Path("/{version}/apps")
@Produces({"application/xml", "application/json"})
public class ApplicationsResource {
    private final EurekaServerConfig serverConfig;
    private final PeerAwareInstanceRegistry registry;
    private final ResponseCache responseCache;

    // 符合规则 /apps/{appName}
    @Path("{appId}")
    public ApplicationResource getApplicationResource(
            @PathParam("version") String version,
            @PathParam("appId") String appId) {
        CurrentRequestVersion.set(Version.toEnum(version));
        try {
            // 真正的入口
            return new ApplicationResource(appId, serverConfig, registry);
        } finally {
            CurrentRequestVersion.remove();
        }
    }
}

/////////////////////////////////

@Produces({"application/xml", "application/json"})
public class ApplicationResource {

    private final PeerAwareInstanceRegistry registry;

    @POST
    @Consumes({"application/json", "application/xml"})
    public Response addInstance(InstanceInfo info,
                                @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication) {
        logger.debug("Registering instance {} (replication={})", info.getId(), isReplication);

        registry.register(info, "true".equals(isReplication));
        return Response.status(204).build();  // 204 to be backwards compatible
    }
}

addInstance 接口有两个参数：

• InstanceInfo：服务实例，主要有两块数据：
  • 基本信息：主机名、IP地址、端口号、URL地址
  • 租约信息：保持心跳的间隔时间、最近心跳的时间、服务注册的时间、服务启动的时间
• isReplication：这个参数是从请求头中取的，表示是否是在同步 server 节点的实例。在集群模式下，因为客户端实例注册到注册中心后，会同步到其它 server节点，所以如果是eureka-server之间同步信息，这个参数就为 true，避免循环同步。

② 实例注册

进入到注册表的 register 方法，可以看到主要就是调用父类的 register 方法注册实例，然后同步到 eureka server 集群中的其它 server 节点。集群同步放到后面来看，现在只需要知道注册实例时会同步到其它server节点即可。

@Override
public void register(final InstanceInfo info, final boolean isReplication) {
    int leaseDuration = Lease.DEFAULT_DURATION_IN_SECS;
    // 如果实例中没有周期的配置，就设置为默认的 90 秒
    if (info.getLeaseInfo() != null && info.getLeaseInfo().getDurationInSecs() > 0) {
        leaseDuration = info.getLeaseInfo().getDurationInSecs();
    }
    // 注册实例
    super.register(info, leaseDuration, isReplication);
    // 复制到集群其它 server 节点
    replicateToPeers(Action.Register, info.getAppName(), info.getId(), info, null, isReplication);
}

接着看父类的注册方法，它的主要流程如下：

• 首先可以看到eureka server保存注册表（registry）的数据结构是 ConcurrentHashMap<String, Map<String, Lease<InstanceInfo>>>，key 就是服务名称，value 就是对应的实例，因为一个服务可能会部署多个实例。
• 根据服务名称从注册表拿到实例表，然后根据实例ID拿到实例的租约信息 Lease<InstanceInfo>
• 如果租约信息存在，说明已经注册过相同的实例了，然后就对比已存在实例和新注册实例的最后更新时间，如果新注册的是旧的，就替换为已存在的实例来完成注册
• 如果租约信息不存在，说明是一个新注册的实例，这时会更新两个阈值：
  • 期望续约的客户端数量 +1
  • 每分钟续约次数的阈值，如果低于这个值，说明有很多客户端没有发送心跳，这时eureka就认为可能网络出问题了，就会有另一些机制，这个后面再说
• 然后就根据注册的实例信息和续约周期创建新的租约，并放入注册表中去
• 接着根据当前时间戳、服务名称、实例ID封装一个 Pair，然后放入到最近注册的队列中 recentRegisteredQueue，先记住这个队列就行了
• 根据实例的 overriddenStatus 判断，不为空的话，可能就只是要更新实例的状态，这个时候就会只变更实例的状态，而不会改变 dirty
• 然后是设置了实例的启动时间戳，设置了实例的 ActionType 为 ADDED
• 将租约加入到最近变更的队列 recentlyChangedQueue，先记住这个队列
• 最后一步失效缓存，一步步进去可以发现，主要就是将读写缓存 readWriteCacheMap 中与这个实例相关的缓存失效掉，这个缓存后面分析抓取注册表的时候再来细看

public void register(InstanceInfo registrant, int leaseDuration, boolean isReplication) {
    read.lock();
    try {
        // registry => ConcurrentHashMap<String, Map<String, Lease<InstanceInfo>>>
        Map<String, Lease<InstanceInfo>> gMap = registry.get(registrant.getAppName());
        REGISTER.increment(isReplication);
        if (gMap == null) {
            // 初次注册时，创建一个 ConcurrentHashMap，key 为 appName
            final ConcurrentHashMap<String, Lease<InstanceInfo>> gNewMap = new ConcurrentHashMap<String, Lease<InstanceInfo>>();
            gMap = registry.putIfAbsent(registrant.getAppName(), gNewMap);
            if (gMap == null) {
                gMap = gNewMap;
            }
        }
        Lease<InstanceInfo> existingLease = gMap.get(registrant.getId());
        // Retain the last dirty timestamp without overwriting it, if there is already a lease
        if (existingLease != null && (existingLease.getHolder() != null)) {
            // 已存在的实例的最后更新时间
            Long existingLastDirtyTimestamp = existingLease.getHolder().getLastDirtyTimestamp();
            // 新注册的实例的最后更新时间
            Long registrationLastDirtyTimestamp = registrant.getLastDirtyTimestamp();
            logger.debug("Existing lease found (existing={}, provided={}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);

            // 如果存在的实例比新注册尽量的实例后更新，就直接把新注册的实例设置为已存在的实例
            if (existingLastDirtyTimestamp > registrationLastDirtyTimestamp) {
                logger.warn("There is an existing lease and the existing lease's dirty timestamp {} is greater" +
                        " than the one that is being registered {}", existingLastDirtyTimestamp, registrationLastDirtyTimestamp);
                logger.warn("Using the existing instanceInfo instead of the new instanceInfo as the registrant");
                registrant = existingLease.getHolder();
            }
        } else {
            // 新注册时，续约信息不存在
            synchronized (lock) {
                if (this.expectedNumberOfClientsSendingRenews > 0) {
                    // Since the client wants to register it, increase the number of clients sending renews
                    // 期望续约的客户端数量 + 1
                    this.expectedNumberOfClientsSendingRenews = this.expectedNumberOfClientsSendingRenews + 1;
                    // 更新每分钟续约请求次数的阀值，这个阀值在后面很多地方都会用到
                    updateRenewsPerMinThreshold();
                }
            }
            logger.debug("No previous lease information found; it is new registration");
        }
        // 创建新的续约
        Lease<InstanceInfo> lease = new Lease<InstanceInfo>(registrant, leaseDuration);
        if (existingLease != null) {
            lease.setServiceUpTimestamp(existingLease.getServiceUpTimestamp());
        }
        gMap.put(registrant.getId(), lease);
        // 放入最近注册的队列
        recentRegisteredQueue.add(new Pair<Long, String>(
                System.currentTimeMillis(),
                registrant.getAppName() + "(" + registrant.getId() + ")"));
        // 覆盖状态
        if (!InstanceStatus.UNKNOWN.equals(registrant.getOverriddenStatus())) {
            logger.debug("Found overridden status {} for instance {}. Checking to see if needs to be add to the "
                            + "overrides", registrant.getOverriddenStatus(), registrant.getId());
            if (!overriddenInstanceStatusMap.containsKey(registrant.getId())) {
                logger.info("Not found overridden id {} and hence adding it", registrant.getId());
                overriddenInstanceStatusMap.put(registrant.getId(), registrant.getOverriddenStatus());
            }
        }
        InstanceStatus overriddenStatusFromMap = overriddenInstanceStatusMap.get(registrant.getId());
        if (overriddenStatusFromMap != null) {
            logger.info("Storing overridden status {} from map", overriddenStatusFromMap);
            registrant.setOverriddenStatus(overriddenStatusFromMap);
        }

        // Set the status based on the overridden status rules
        InstanceStatus overriddenInstanceStatus = getOverriddenInstanceStatus(registrant, existingLease, isReplication);
        // 仅仅是变更实例状态，不会设置为 dirty
        registrant.setStatusWithoutDirty(overriddenInstanceStatus);

        // If the lease is registered with UP status, set lease service up timestamp
        if (InstanceStatus.UP.equals(registrant.getStatus())) {
            // UP 时设置 Lease 的时间戳
            lease.serviceUp();
        }
        // 设置动作是 ADDED，这个在后面会做 switch 判断
        registrant.setActionType(ActionType.ADDED);
        // 添加到最近变更的队列
        recentlyChangedQueue.add(new RecentlyChangedItem(lease));
        // 设置最后更新时间
        registrant.setLastUpdatedTimestamp();
        // 失效缓存
        invalidateCache(registrant.getAppName(), registrant.getVIPAddress(), registrant.getSecureVipAddress());
        logger.info("Registered instance {}/{} with status {} (replication={})",
                registrant.getAppName(), registrant.getId(), registrant.getStatus(), isReplication);
    } finally {
        read.unlock();
    }
}

更新每分钟续约次数的阈值：

protected void updateRenewsPerMinThreshold() {
    // 每分钟续约阈值 = 期望续约的客户端数量 * （60 / 续约间隔时间） * 续约百分比
    // 例如，一共注册了 10 个实例，那么期望续约的客户端数量为 10，间隔时间默认为 30秒，就是每个客户端应该每30秒发送一次心跳，续约百分比默认为 0.85
    // 每分钟续约次数阈值 = 10 * (60.0 / 30) * 0.85 = 17，也就是说每分钟至少要接收到 17 此续约请求
    this.numberOfRenewsPerMinThreshold = (int) (this.expectedNumberOfClientsSendingRenews
            * (60.0 / serverConfig.getExpectedClientRenewalIntervalSeconds())
            * serverConfig.getRenewalPercentThreshold());
}

这就是注册表 registry 缓存服务实例信息的结构，可以看出 eureka 是基于内存来组织注册表的，使用的是 ConcurrentHashMap 来保证多线程并发安全。

4、Eureka Server 控制台

前面已经将服务实例注册上去了，现在来看下 eureka server 的控制台页面是怎么获取这些数据的。

前面已经分析过 eureka-server 的 web.xml 中配置了欢迎页为 status.jsp ，这就是控制台的页面。

从 status.jsp 可以看出，其实就是从 EurekaServerContext 上下文获取注册表，然后读取注册表注册的服务实例，然后遍历展示到表格中。

<%@ page language="java" import="java.util.*,java.util.Map.Entry,com.netflix.discovery.shared.Pair,
com.netflix.discovery.shared.*,com.netflix.eureka.util.*,com.netflix.appinfo.InstanceInfo.*,
com.netflix.appinfo.DataCenterInfo.*,com.netflix.appinfo.AmazonInfo.MetaDataKey,com.netflix.eureka.resources.*,
com.netflix.eureka.*,com.netflix.appinfo.*,com.netflix.eureka.util.StatusUtil" pageEncoding="UTF-8" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>
  <head>
    <base href="<%=basePath%>">

    <title>Eureka</title>
    <link rel="stylesheet" type="text/css" href="./css/main.css">
    <script type="text/javascript" src="./js/jquery-1.11.1.js" ></script>
    <script type="text/javascript" src="./js/jquery.dataTables.js" ></script>
    <script type="text/javascript" >
       $(document).ready(function() {
           $('table.stripeable tr:odd').addClass('odd');
           $('table.stripeable tr:even').addClass('even');
           $('#instances thead th').each(function () {
               var title = $('#instances thead th').eq($(this).index()).text();
               $(this).html(title + '</br><input type="text" placeholder="Search ' + title + '" />');
           });
           // DataTable
           var table = $('#instances').DataTable({"paging": false, "bInfo": false, "sDom": 'ltipr', "bSort": false});
           // Apply the search
           table.columns().eq(0).each(function (colIdx) {
               $('input', table.column(colIdx).header()).on('keyup change', function () {
                   table.column(colIdx).search(this.value).draw();
               });
           });
       });
    </script>
  </head>

  <body id="one">
    <jsp:include page="header.jsp" />
    <jsp:include page="navbar.jsp" />
    <div id="content">
      <div class="sectionTitle">Instances currently registered with Eureka</div>
        <table id='instances' class="stripeable">
           <thead><tr><th>Application</th><th>AMIs</th><th>Availability Zones</th><th>Status</th></tr></thead>
           <tfoot><tr><th>Application</th><th>AMIs</th><th>Availability Zones</th><th>Status</th></tr></tfoot>
           <tbody>
           <%
               // 获取 eureka server 上下文 EurekaServerContext
           EurekaServerContext serverContext = (EurekaServerContext) pageContext.getServletContext()
                   .getAttribute(EurekaServerContext.class.getName());
           // 从上下文中取出注册表，
           for(Application app : serverContext.getRegistry().getSortedApplications()) {
               out.print("<tr><td><b>" + app.getName() + "</b></td>");
               Map<String, Integer> amiCounts = new HashMap<String, Integer>();
               Map<InstanceStatus,List<Pair<String, String>>> instancesByStatus =
                   new HashMap<InstanceStatus, List<Pair<String,String>>>();
               Map<String,Integer> zoneCounts = new HashMap<String, Integer>();

               for(InstanceInfo info : app.getInstances()){
                   String id = info.getId();
                   String url = info.getStatusPageUrl();
                   InstanceStatus status = info.getStatus();
                   String ami = "n/a";
                   String zone = "";
                   if(info.getDataCenterInfo().getName() == Name.Amazon){
                       AmazonInfo dcInfo = (AmazonInfo)info.getDataCenterInfo();
                       ami = dcInfo.get(MetaDataKey.amiId);
                       zone = dcInfo.get(MetaDataKey.availabilityZone);
                   }

                   Integer count = amiCounts.get(ami);
                   if(count != null){
                       amiCounts.put(ami, Integer.valueOf(count.intValue()+1));
                   }else {
                       amiCounts.put(ami, Integer.valueOf(1));
                   }

                   count = zoneCounts.get(zone);
                   if(count != null){
                       zoneCounts.put(zone, Integer.valueOf(count.intValue()+1));
                   }else {
                       zoneCounts.put(zone, Integer.valueOf(1));
                   }
                   List<Pair<String, String>> list = instancesByStatus.get(status);

                   if(list == null){
                       list = new ArrayList<Pair<String,String>>();
                       instancesByStatus.put(status, list);
                   }
                   list.add(new Pair<String, String>(id, url));
               }
               StringBuilder buf = new StringBuilder();
               for (Iterator<Entry<String, Integer>> iter =
                   amiCounts.entrySet().iterator(); iter.hasNext();) {
                   Entry<String, Integer> entry = iter.next();
                   buf.append("<b>").append(entry.getKey()).append("</b> (").append(entry.getValue()).append("), ");
               }
               out.println("<td>" + buf.toString() + "</td>");
               buf = new StringBuilder();
               for (Iterator<Entry<String, Integer>> iter =
                   zoneCounts.entrySet().iterator(); iter.hasNext();) {
                   Entry<String, Integer> entry = iter.next();
                   buf.append("<b>").append(entry.getKey()).append("</b> (").append(entry.getValue()).append("), ");
               }
               out.println("<td>" + buf.toString() + "</td>");
               buf = new StringBuilder();
               for (Iterator<Entry<InstanceStatus, List<Pair<String,String>>>> iter =
                   instancesByStatus.entrySet().iterator(); iter.hasNext();) {
                   Entry<InstanceStatus, List<Pair<String,String>>> entry = iter.next();
                   List<Pair<String, String>> value = entry.getValue();
                   InstanceStatus status = entry.getKey();
                   if(status != InstanceStatus.UP){
                       buf.append("<font color=red size=+1><b>");
                   }
                   buf.append("<b>").append(status.name()).append("</b> (").append(value.size()).append(") - ");
                   if(status != InstanceStatus.UP){
                       buf.append("</font></b>");
                   }

                   for(Pair<String,String> p : value) {
                       String id = p.first();
                       String url = p.second();
                       if(url != null && url.startsWith("http")){
                           buf.append("<a href="").append(url).append("">");
                       }else {
                           url = null;
                       }
                       buf.append(id);
                       if(url != null){
                           buf.append("</a>");
                       }
                       buf.append(", ");
                   }
               }
               out.println("<td>" + buf.toString() + "</td></tr>");
           }
           %>
           </tbody>
           </table>
      </div>
      <div>
      <div class="sectionTitle">General Info</div>
      <table id='generalInfo' class="stripeable">
          <tr><th>Name</th><th>Value</th></tr>
           <%
           StatusInfo statusInfo = (new StatusUtil(serverContext)).getStatusInfo();
           Map<String,String> genMap = statusInfo.getGeneralStats();
           for (Map.Entry<String,String> entry : genMap.entrySet()) {
             out.print("<tr>");
             out.print("<td>" + entry.getKey() +  "</td><td>" + entry.getValue() + "</td>");
             out.print("</tr>");
           }
           Map<String,String> appMap = statusInfo.getApplicationStats();
           for (Map.Entry<String,String> entry : appMap.entrySet()) {
             out.print("<tr>");
             out.print("<td>" + entry.getKey() +  "</td><td>" + entry.getValue() + "</td>");
             out.print("</tr>");
           }
           %>
           </table>
      </div>
      <div>
      <div class="sectionTitle">Instance Info</div>
        <table id='instanceInfo' class="stripeable">
          <tr><th>Name</th><th>Value</th></tr>
           <%
           InstanceInfo instanceInfo = statusInfo.getInstanceInfo();
           Map<String,String> instanceMap = new HashMap<String,String>();
           instanceMap.put("ipAddr", instanceInfo.getIPAddr());
           instanceMap.put("status", instanceInfo.getStatus().toString());
           if(instanceInfo.getDataCenterInfo().getName() == DataCenterInfo.Name.Amazon) {
               AmazonInfo info = (AmazonInfo) instanceInfo.getDataCenterInfo();
               instanceMap.put("availability-zone", info.get(AmazonInfo.MetaDataKey.availabilityZone));
               instanceMap.put("public-ipv4", info.get(AmazonInfo.MetaDataKey.publicIpv4));
               instanceMap.put("instance-id", info.get(AmazonInfo.MetaDataKey.instanceId));
               instanceMap.put("public-hostname", info.get(AmazonInfo.MetaDataKey.publicHostname));
               instanceMap.put("ami-id", info.get(AmazonInfo.MetaDataKey.amiId));
               instanceMap.put("instance-type", info.get(AmazonInfo.MetaDataKey.instanceType));
           }
           for (Map.Entry<String,String> entry : instanceMap.entrySet()) {
             out.print("<tr>");
             out.print("<td>" + entry.getKey() +  "</td><td>" + entry.getValue() + "</td>");
             out.print("</tr>");
           }
           %>
           </table>
    </div>

  </body>
</html>

5、服务注册的整体流程图

下面通过一张图来看看服务实例注册的整个流程。

六、抓取注册表

1、Eureka Client 启动时全量抓取注册表

客户端启动初始化 DiscoveryClient 时，其中有段代码如下：这一步调用 fetchRegistry 就是在启动时全量抓取注册表缓存到本地中。

if (clientConfig.shouldFetchRegistry()) {
    try {
        // 拉取注册表：全量抓取和增量抓取
        boolean primaryFetchRegistryResult = fetchRegistry(false);
        if (!primaryFetchRegistryResult) {
            logger.info("Initial registry fetch from primary servers failed");
        }
        boolean backupFetchRegistryResult = true;
        if (!primaryFetchRegistryResult && !fetchRegistryFromBackup()) {
            backupFetchRegistryResult = false;
            logger.info("Initial registry fetch from backup servers failed");
        }
        if (!primaryFetchRegistryResult && !backupFetchRegistryResult && clientConfig.shouldEnforceFetchRegistryAtInit()) {
            throw new IllegalStateException("Fetch registry error at startup. Initial fetch failed.");
        }
    } catch (Throwable th) {
        logger.error("Fetch registry error at startup: {}", th.getMessage());
        throw new IllegalStateException(th);
    }
}

进入 fetchRegistry 方法，可以看到，首先获取本地的 Applications，如果为空就会调用 getAndStoreFullRegistry 方法全量抓取注册表并缓存到本地。

private boolean fetchRegistry(boolean forceFullRegistryFetch) {
    Stopwatch tracer = FETCH_REGISTRY_TIMER.start();

    try {
        // 获取本地的应用实例
        Applications applications = getApplications();

        if (clientConfig.shouldDisableDelta()
                || (!Strings.isNullOrEmpty(clientConfig.getRegistryRefreshSingleVipAddress()))
                || forceFullRegistryFetch
                || (applications == null)
                || (applications.getRegisteredApplications().size() == 0)
                || (applications.getVersion() == -1)) //Client application does not have latest library supporting delta
        {
            // 全量抓取注册表
            getAndStoreFullRegistry();
        } else {
            // 增量更新注册表
            getAndUpdateDelta(applications);
        }
        applications.setAppsHashCode(applications.getReconcileHashCode());
        logTotalInstances();
    } catch (Throwable e) {
        logger.info(PREFIX + "{} - was unable to refresh its cache! This periodic background refresh will be retried in {} seconds. status = {} stacktrace = {}",
                appPathIdentifier, clientConfig.getRegistryFetchIntervalSeconds(), e.getMessage(), ExceptionUtils.getStackTrace(e));
        return false;
    } finally {
        if (tracer != null) {
            tracer.stop();
        }
    }

    // 发出缓存刷新的通知
    onCacheRefreshed();

    // Update remote status based on refreshed data held in the cache
    updateInstanceRemoteStatus();

    // registry was fetched successfully, so return true
    return true;
}

进入 getAndStoreFullRegistry  方法可以发现，就是调用 GET /apps 接口抓取全量注册表，因此等会服务端就从这个入口进去看抓取全量注册表的逻辑。注册表抓取回来之后，就放到本地变量 localRegionApps 中。localRegionApps 的类型是 AtomicReference<Applications>，实例信息是存储在 Applications 中的。

private boolean fetchRegistry(boolean forceFullRegistryFetch) {
    Stopwatch tracer = FETCH_REGISTRY_TIMER.start();

    try {
        // 获取本地的应用实例
        Applications applications = getApplications();

        if (clientConfig.shouldDisableDelta()
                || (!Strings.isNullOrEmpty(clientConfig.getRegistryRefreshSingleVipAddress()))
                || forceFullRegistryFetch
                || (applications == null)
                || (applications.getRegisteredApplications().size() == 0)
                || (applications.getVersion() == -1)) //Client application does not have latest library supporting delta
        {
            // 全量抓取注册表
            getAndStoreFullRegistry();
        } else {
            // 增量更新注册表
            getAndUpdateDelta(applications);
        }
        applications.setAppsHashCode(applications.getReconcileHashCode());
        logTotalInstances();
    } catch (Throwable e) {
        logger.info(PREFIX + "{} - was unable to refresh its cache! This periodic background refresh will be retried in {} seconds. status = {} stacktrace = {}",
                appPathIdentifier, clientConfig.getRegistryFetchIntervalSeconds(), e.getMessage(), ExceptionUtils.getStackTrace(e));
        return false;
    } finally {
        if (tracer != null) {
            tracer.stop();
        }
    }

    // 发出缓存刷新的通知
    onCacheRefreshed();

    // Update remote status based on refreshed data held in the cache
    updateInstanceRemoteStatus();

    // registry was fetched successfully, so return true
    return true;
}

2、Eureka Server 注册表多级缓存机制

① 全量抓取注册表的接口

全量抓取注册表的接口是 GET /apps，跟找注册接口是类似的，最终可以找到 ApplicationsResource 的 getContainers 方法就是全量抓取注册表的入口。

• 可以看出，我们可以通过请求头来指定返回 xml 格式还是 json 格式，可以指定是否要压缩返回等。
• 然后创建了全量缓存的 Key
• 接着根据缓存的 key 从 responseCache 中全量抓取注册表

@GET
public Response getContainers(@PathParam("version") String version,
                              @HeaderParam(HEADER_ACCEPT) String acceptHeader,
                              @HeaderParam(HEADER_ACCEPT_ENCODING) String acceptEncoding,
                              @HeaderParam(EurekaAccept.HTTP_X_EUREKA_ACCEPT) String eurekaAccept,
                              @Context UriInfo uriInfo,
                              @Nullable @QueryParam("regions") String regionsStr) {
    // 省略部分代码...

    // JSON 类型
    KeyType keyType = Key.KeyType.JSON;
    String returnMediaType = MediaType.APPLICATION_JSON;
    if (acceptHeader == null || !acceptHeader.contains(HEADER_JSON_VALUE)) {
        keyType = Key.KeyType.XML;
        returnMediaType = MediaType.APPLICATION_XML;
    }

    // 全量注册表的缓存key
    Key cacheKey = new Key(Key.EntityType.Application,
            ResponseCacheImpl.ALL_APPS,
            keyType, CurrentRequestVersion.get(), EurekaAccept.fromString(eurekaAccept), regions
    );

    Response response;
    if (acceptEncoding != null && acceptEncoding.contains(HEADER_GZIP_VALUE)) {
        // 压缩返回
        response = Response.ok(responseCache.getGZIP(cacheKey))
                .header(HEADER_CONTENT_ENCODING, HEADER_GZIP_VALUE)
                .header(HEADER_CONTENT_TYPE, returnMediaType)
                .build();
    } else {
        // 根据缓存 key 从 responseCache 获取全量注册表
        response = Response.ok(responseCache.get(cacheKey))
                .build();
    }
    CurrentRequestVersion.remove();
    return response;
}

② ResponseCache 多级缓存读取

ResponseCache 就是 eureka server 读取注册表的核心组件，它的内部采用了多级缓存的机制来快速响应客户端抓取注册表的请求，下面就来看看 ResponseCache。

缓存读取的流程：

• 如果设置了使用只读缓存（默认true），就先从只读缓存 readOnlyCacheMap 中读取；readOnlyCacheMap 使用 ConcurrentHashMap 实现，ConcurrentHashMap 支持并发访问，读取速度很快。
• 如果读写缓存中没有，就从读写缓存 readWriteCacheMap 中读取，读取出来后并写入到只读缓存中；readWriteCacheMap 使用 google guava 的 LoadingCache 实现，LoadingCache 支持在没有元素的时候使用 CacheLoader 加载元素。
• 如果没有开启使用只读缓存，就直接从读写缓存中获取。

public String get(final Key key) {
    return get(key, shouldUseReadOnlyResponseCache);
}

////////////////////////////////////////////////////

String get(final Key key, boolean useReadOnlyCache) {
    // => getValue
    Value payload = getValue(key, useReadOnlyCache);
    if (payload == null || payload.getPayload().equals(EMPTY_PAYLOAD)) {
        return null;
    } else {
        return payload.getPayload();
    }
}

////////////////////////////////////////////////////

Value getValue(final Key key, boolean useReadOnlyCache) {
    Value payload = null;
    try {
        if (useReadOnlyCache) {
            // 开启使用只读缓存，则先从只读缓存读取
            // readOnlyCacheMap => ConcurrentHashMap<Key, Value>
            final Value currentPayload = readOnlyCacheMap.get(key);
            if (currentPayload != null) {
                payload = currentPayload;
            } else {
                // 只读缓存中没有，则从读写缓存中读取，然后放入只读缓存中
                // readWriteCacheMap => LoadingCache<Key, Value>
                payload = readWriteCacheMap.get(key);
                readOnlyCacheMap.put(key, payload);
            }
        } else {
            // 未开启只读缓存，就从读写缓存中读取
            payload = readWriteCacheMap.get(key);
        }
    } catch (Throwable t) {
        logger.error("Cannot get value for key : {}", key, t);
    }
    return payload;
}

③ ResponseCache 初始化

分析 eureka server EurekaBootStrap 启动初始化时，最后有一步去初始化 eureka server 上下文，它里面就会去初始化注册表，初始化注册表的时候就会初始化 ResponseCache，这里就来分析下这个初始化干了什么。

• 主要就是使用 google guava cache 构造了一个读写缓存 readWriteCacheMap，初始容量为 1000。注意这个读写缓存的特性：每隔 180 秒定时过期，然后元素不存在的时候就会使用 CacheLoader 从注册表中读取。
• 接着如果配置了使用只读缓存，还会开启一个定时任务，每隔30秒将读写缓存 readWriteCacheMap 的数据同步到只读缓存 readOnlyCacheMap。

ResponseCacheImpl(EurekaServerConfig serverConfig, ServerCodecs serverCodecs, AbstractInstanceRegistry registry) {
    this.serverConfig = serverConfig;
    this.serverCodecs = serverCodecs;
    // 是否使用只读缓存，默认为 true
    this.shouldUseReadOnlyResponseCache = serverConfig.shouldUseReadOnlyResponseCache();
    // 保存注册表
    this.registry = registry;
    // 缓存更新间隔时间，默认30秒
    long responseCacheUpdateIntervalMs = serverConfig.getResponseCacheUpdateIntervalMs();
    // 使用 google guava cache 构造一个读写缓存
    this.readWriteCacheMap =
            // 初始容量为1000
            CacheBuilder.newBuilder().initialCapacity(serverConfig.getInitialCapacityOfResponseCache())
                    // 缓存的数据在写入多久后过期，默认180秒，也就是说 readWriteCacheMap 会定时过期
                    .expireAfterWrite(serverConfig.getResponseCacheAutoExpirationInSeconds(), TimeUnit.SECONDS)
                    .removalListener(new RemovalListener<Key, Value>() {
                        @Override
                        public void onRemoval(RemovalNotification<Key, Value> notification) {
                            Key removedKey = notification.getKey();
                            if (removedKey.hasRegions()) {
                                Key cloneWithNoRegions = removedKey.cloneWithoutRegions();
                                regionSpecificKeys.remove(cloneWithNoRegions, removedKey);
                            }
                        }
                    })
                    // 当key对应的元素不存在时，使用定义 CacheLoader 加载元素
                    .build(new CacheLoader<Key, Value>() {
                        @Override
                        public Value load(Key key) throws Exception {
                            if (key.hasRegions()) {
                                Key cloneWithNoRegions = key.cloneWithoutRegions();
                                regionSpecificKeys.put(cloneWithNoRegions, key);
                            }
                            // 获取元素
                            Value value = generatePayload(key);
                            return value;
                        }
                    });

    if (shouldUseReadOnlyResponseCache) {
        // 如果配置了使用只读缓存，就开启一个定时任务，定期将 readWriteCacheMap 的数据同步到 readOnlyCacheMap 中
        // 默认间隔时间是 30 秒
        timer.schedule(getCacheUpdateTask(),
                new Date(((System.currentTimeMillis() / responseCacheUpdateIntervalMs) * responseCacheUpdateIntervalMs)
                        + responseCacheUpdateIntervalMs),
                responseCacheUpdateIntervalMs);
    }

    try {
        Monitors.registerObject(this);
    } catch (Throwable e) {
        logger.warn("Cannot register the JMX monitor for the InstanceRegistry", e);
    }
}

generatePayload 方法：

private Value generatePayload(Key key) {
    Stopwatch tracer = null;
    try {
        String payload;
        switch (key.getEntityType()) {
            case Application:
                boolean isRemoteRegionRequested = key.hasRegions();

                // 获取所有应用
                if (ALL_APPS.equals(key.getName())) {
                    if (isRemoteRegionRequested) {
                        tracer = serializeAllAppsWithRemoteRegionTimer.start();
                        payload = getPayLoad(key, registry.getApplicationsFromMultipleRegions(key.getRegions()));
                    } else {
                        tracer = serializeAllAppsTimer.start();
                        // 从注册表读取所有服务实例
                        payload = getPayLoad(key, registry.getApplications());
                    }
                }
                // 增量获取应用
                else if (ALL_APPS_DELTA.equals(key.getName())) {
                    if (isRemoteRegionRequested) {
                        tracer = serializeDeltaAppsWithRemoteRegionTimer.start();
                        versionDeltaWithRegions.incrementAndGet();
                        versionDeltaWithRegionsLegacy.incrementAndGet();
                        payload = getPayLoad(key,
                                registry.getApplicationDeltasFromMultipleRegions(key.getRegions()));
                    } else {
                        tracer = serializeDeltaAppsTimer.start();
                        versionDelta.incrementAndGet();
                        versionDeltaLegacy.incrementAndGet();
                        payload = getPayLoad(key, registry.getApplicationDeltas());
                    }
                } else {
                    tracer = serializeOneApptimer.start();
                    payload = getPayLoad(key, registry.getApplication(key.getName()));
                }
                break;
            case VIP:
            case SVIP:
                tracer = serializeViptimer.start();
                payload = getPayLoad(key, getApplicationsForVip(key, registry));
                break;
            default:
                logger.error("Unidentified entity type: {} found in the cache key.", key.getEntityType());
                payload = "";
                break;
        }
        return new Value(payload);
    } finally {
        if (tracer != null) {
            tracer.stop();
        }
    }
}

3、Eureka Server 注册表多级缓存过期机制

这节来总结下 eureka server 注册表多级缓存的过期时机，其实前面都已经分析过了。

① 主动过期

分析服务注册时已经说过，服务注册完成后，调用了 invalidateCache 来失效缓存，进去可以看到就是将读写缓存 readWriteCacheMap 中的服务、所有服务、增量服务的缓存失效掉。

那这里就要注意了，如果服务注册、下线、故障之类的，这里只是失效了读写缓存，然后可能要间隔30秒才能同步到只读缓存 readOnlyCacheMap，那么其它客户端可能要隔30秒后才能感知到。

private void invalidateCache(String appName, @Nullable String vipAddress, @Nullable String secureVipAddress) {
    // invalidate cache
    responseCache.invalidate(appName, vipAddress, secureVipAddress);
}

缓存失效：

@Override
public void invalidate(String appName, @Nullable String vipAddress, @Nullable String secureVipAddress) {
    for (Key.KeyType type : Key.KeyType.values()) {
        for (Version v : Version.values()) {
            invalidate(
                    // 失效服务的缓存
                    new Key(Key.EntityType.Application, appName, type, v, EurekaAccept.full),
                    new Key(Key.EntityType.Application, appName, type, v, EurekaAccept.compact),
                    // 失效所有 APP 的缓存
                    new Key(Key.EntityType.Application, ALL_APPS, type, v, EurekaAccept.full),
                    new Key(Key.EntityType.Application, ALL_APPS, type, v, EurekaAccept.compact),
                    // 失效增量 APP 的缓存
                    new Key(Key.EntityType.Application, ALL_APPS_DELTA, type, v, EurekaAccept.full),
                    new Key(Key.EntityType.Application, ALL_APPS_DELTA, type, v, EurekaAccept.compact)
            );
            if (null != vipAddress) {
                invalidate(new Key(Key.EntityType.VIP, vipAddress, type, v, EurekaAccept.full));
            }
            if (null != secureVipAddress) {
                invalidate(new Key(Key.EntityType.SVIP, secureVipAddress, type, v, EurekaAccept.full));
            }
        }
    }
}

public void invalidate(Key... keys) {
    for (Key key : keys) {
        logger.debug("Invalidating the response cache key : {} {} {} {}, {}",
                key.getEntityType(), key.getName(), key.getVersion(), key.getType(), key.getEurekaAccept());

        // 失效读写缓存
        readWriteCacheMap.invalidate(key);
        Collection<Key> keysWithRegions = regionSpecificKeys.get(key);
        if (null != keysWithRegions && !keysWithRegions.isEmpty()) {
            for (Key keysWithRegion : keysWithRegions) {
                logger.debug("Invalidating the response cache key : {} {} {} {} {}",
                        key.getEntityType(), key.getName(), key.getVersion(), key.getType(), key.getEurekaAccept());
                readWriteCacheMap.invalidate(keysWithRegion);
            }
        }
    }
}

② 定时过期

读写缓存 readWriteCacheMap 在构建的时候，指定了一个自动过期的时间，默认值是180秒，所以往 readWriteCacheMap 中放入一个数据过后，等180秒过后，它就自动过期了。然后下次读取的时候发现缓存中没有这个 key，就会使用 CacheLoader 重新加载到这个缓存中。

这种定时过期机制就是每隔一段时间来同步注册表与缓存的数据。

③ 被动过期

初始化 ResponseCache 时，如果启用了只读缓存，就会创建一个定时任务（每隔30秒运行一次）来同步 readWriteCacheMap 与 readOnlyCacheMap 中的数据，对于 readOnlyCacheMap 来说这就是一种被动过期。

private TimerTask getCacheUpdateTask() {
    return new TimerTask() {
        @Override
        public void run() {
            logger.debug("Updating the client cache from response cache");
            for (Key key : readOnlyCacheMap.keySet()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Updating the client cache from response cache for key : {} {} {} {}",
                            key.getEntityType(), key.getName(), key.getVersion(), key.getType());
                }
                try {
                    CurrentRequestVersion.set(key.getVersion());
                    // 获取读写缓存中的数据
                    Value cacheValue = readWriteCacheMap.get(key);
                    // 获取只读缓存中的数据
                    Value currentCacheValue = readOnlyCacheMap.get(key);
                    // 如果 readOnlyCacheMap 中缓存的值与 readWriteCacheMap 缓存的值不同，就用 readWriteCacheMap 的值覆盖 readOnlyCacheMap 的值
                    if (cacheValue != currentCacheValue) {
                        readOnlyCacheMap.put(key, cacheValue);
                    }
                } catch (Throwable th) {
                    logger.error("Error while updating the client cache from response cache for key {}", key.toStringCompact(), th);
                } finally {
                    CurrentRequestVersion.remove();
                }
            }
        }
    };
}

4、Eureka Client 定时拉取增量注册表

① 客户端注册表刷新定时任务

前面介绍 DiscoveryClient 初始化时，在初始化调度任务这一步，如果要抓取注册表，就会创建一个调度器每隔 30 秒执行一次 cacheRefreshTask，它对 CacheRefreshThread 做了封装，进去可以看到，它其实就是调用 refreshRegistry 方法刷新注册表。

private void initScheduledTasks() {
    if (clientConfig.shouldFetchRegistry()) {
        // 抓取注册表的间隔时间，默认30秒
        int registryFetchIntervalSeconds = clientConfig.getRegistryFetchIntervalSeconds();
        // 刷新缓存调度器延迟时间扩大倍数，在任务超时的时候，将扩大延迟时间
        // 这在出现网络抖动、eureka-sever 不可用时，可以避免频繁发起无效的调度
        int expBackOffBound = clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
        // 注册表刷新的定时任务
        cacheRefreshTask = new TimedSupervisorTask(
                "cacheRefresh",
                scheduler,
                cacheRefreshExecutor,
                registryFetchIntervalSeconds,
                TimeUnit.SECONDS,
                expBackOffBound,
                new CacheRefreshThread() // 刷新注册表的任务
        );
        // 30秒后开始调度刷新注册表的任务
        scheduler.schedule(
                cacheRefreshTask,
                registryFetchIntervalSeconds, TimeUnit.SECONDS);
    }
}

refreshRegistry 方法：

class CacheRefreshThread implements Runnable {
    public void run() {
        refreshRegistry();
    }
}

@VisibleForTesting
void refreshRegistry() {
    try {
        boolean isFetchingRemoteRegionRegistries = isFetchingRemoteRegionRegistries();

        boolean remoteRegionsModified = false;
        // This makes sure that a dynamic change to remote regions to fetch is honored.
        String latestRemoteRegions = clientConfig.fetchRegistryForRemoteRegions();
        if (null != latestRemoteRegions) {
            String currentRemoteRegions = remoteRegionsToFetch.get();
            if (!latestRemoteRegions.equals(currentRemoteRegions)) {
                // Both remoteRegionsToFetch and AzToRegionMapper.regionsToFetch need to be in sync
                synchronized (instanceRegionChecker.getAzToRegionMapper()) {
                    if (remoteRegionsToFetch.compareAndSet(currentRemoteRegions, latestRemoteRegions)) {
                        String[] remoteRegions = latestRemoteRegions.split(",");
                        remoteRegionsRef.set(remoteRegions);
                        instanceRegionChecker.getAzToRegionMapper().setRegionsToFetch(remoteRegions);
                        remoteRegionsModified = true;
                    } else {
                        logger.info("Remote regions to fetch modified concurrently," +
                                " ignoring change from {} to {}", currentRemoteRegions, latestRemoteRegions);
                    }
                }
            } else {
                // Just refresh mapping to reflect any DNS/Property change
                instanceRegionChecker.getAzToRegionMapper().refreshMapping();
            }
        }

        // 抓取注册表
        boolean success = fetchRegistry(remoteRegionsModified);
        if (success) {
            registrySize = localRegionApps.get().size();
            lastSuccessfulRegistryFetchTimestamp = System.currentTimeMillis();
        }

        if (logger.isDebugEnabled()) {
            StringBuilder allAppsHashCodes = new StringBuilder();
            allAppsHashCodes.append("Local region apps hashcode: ");
            allAppsHashCodes.append(localRegionApps.get().getAppsHashCode());
            allAppsHashCodes.append(", is fetching remote regions? ");
            allAppsHashCodes.append(isFetchingRemoteRegionRegistries);
            for (Map.Entry<String, Applications> entry : remoteRegionVsApps.entrySet()) {
                allAppsHashCodes.append(", Remote region: ");
                allAppsHashCodes.append(entry.getKey());
                allAppsHashCodes.append(" , apps hashcode: ");
                allAppsHashCodes.append(entry.getValue().getAppsHashCode());
            }
            logger.debug("Completed cache refresh task for discovery. All Apps hash code is {} ",
                    allAppsHashCodes);
        }
    } catch (Throwable e) {
        logger.error("Cannot fetch registry from server", e);
    }
}

refreshRegistry 里面又调用了 fetchRegistry 抓取注册表，fetchRegistry 在前面分析全量抓取注册表时已经展示过了。全量抓取注册表之后，本地 applications 不为空了，这时就会走 getAndUpdateDelta 增量更新的方法。

private boolean fetchRegistry(boolean forceFullRegistryFetch) {
    Stopwatch tracer = FETCH_REGISTRY_TIMER.start();

    try {
        // 获取本地的应用实例
        Applications applications = getApplications();

        if (clientConfig.shouldDisableDelta()
                || (!Strings.isNullOrEmpty(clientConfig.getRegistryRefreshSingleVipAddress()))
                || forceFullRegistryFetch
                || (applications == null)
                || (applications.getRegisteredApplications().size() == 0)
                || (applications.getVersion() == -1)) //Client application does not have latest library supporting delta
        {
            logger.info("Disable delta property : {}", clientConfig.shouldDisableDelta());
            logger.info("Single vip registry refresh property : {}", clientConfig.getRegistryRefreshSingleVipAddress());
            logger.info("Force full registry fetch : {}", forceFullRegistryFetch);
            logger.info("Application is null : {}", (applications == null));
            logger.info("Registered Applications size is zero : {}",
                    (applications.getRegisteredApplications().size() == 0));
            logger.info("Application version is -1: {}", (applications.getVersion() == -1));
            // 全量抓取注册表
            getAndStoreFullRegistry();
        } else {
            // 增量更新注册表
            getAndUpdateDelta(applications);
        }
        applications.setAppsHashCode(applications.getReconcileHashCode());
        logTotalInstances();
    } catch (Throwable e) {
        logger.info(PREFIX + "{} - was unable to refresh its cache! This periodic background refresh will be retried in {} seconds. status = {} stacktrace = {}",
                appPathIdentifier, clientConfig.getRegistryFetchIntervalSeconds(), e.getMessage(), ExceptionUtils.getStackTrace(e));
        return false;
    } finally {
        if (tracer != null) {
            tracer.stop();
        }
    }

    // 发出刷新缓存的通知
    onCacheRefreshed();

    // Update remote status based on refreshed data held in the cache
    updateInstanceRemoteStatus();

    // registry was fetched successfully, so return true
    return true;
}

② 增量更新本地注册表

接着看 getAndUpdateDelta 增量更新方法：

• 首先调用 eureka server GET /apps/delta 接口获取增量的注册表
• 如果增量的注册表为空，就会调用 getAndStoreFullRegistry 方法全量抓取注册表
• 增量注册表不为空，就将其合并到本地注册表中
• 然后根据本地注册表的 applications 重新计算一个 hash 值
• eureka server 返回的 delta 中包含一个 appsHashCode，代表了 eureka server 端的注册表的 hash 值，如果与本地计算的 hash 值不同，则说明本地注册表与server端注册表不一致，那就会全量拉取注册表更新到本地缓存中

可以看到，eureka 增量抓取的思路来更新本地缓存，并使用了 hash 值来保证服务端与本地的数据一致性。在分布式系统里，要进行数据同步，采用 hash 值比对的思想，这是值得学习的一个思路。

private void getAndUpdateDelta(Applications applications) throws Throwable {
    long currentUpdateGeneration = fetchRegistryGeneration.get();

    Applications delta = null;
    // 调用远程接口增量抓取：GET apps/delta
    EurekaHttpResponse<Applications> httpResponse = eurekaTransport.queryClient.getDelta(remoteRegionsRef.get());
    if (httpResponse.getStatusCode() == Status.OK.getStatusCode()) {
        delta = httpResponse.getEntity();
    }

    // 如果增量抓取的数据为空，就会进行一次全量抓取
    if (delta == null) {
        logger.warn("The server does not allow the delta revision to be applied because it is not safe. "
                + "Hence got the full registry.");
        getAndStoreFullRegistry();
    }

    else if (fetchRegistryGeneration.compareAndSet(currentUpdateGeneration, currentUpdateGeneration + 1)) {
        logger.debug("Got delta update with apps hashcode {}", delta.getAppsHashCode());
        String reconcileHashCode = "";
        // 加锁更新本地注册表
        if (fetchRegistryUpdateLock.tryLock()) {
            try {
                // 抓取到增量的注册表后，跟本地的注册表合并
                updateDelta(delta);
                // 注册表合并完成后，根据本地 applications 计算一个 hash 值
                reconcileHashCode = getReconcileHashCode(applications);
            } finally {
                fetchRegistryUpdateLock.unlock();
            }
        } else {
            logger.warn("Cannot acquire update lock, aborting getAndUpdateDelta");
        }
        // delta 中会返回 server 端注册表的 hash 值，如果和本地计算出来的 hash 值不一样，
        // 说明本地注册表跟 server 端注册表不一样，就会从 server 全量拉取注册表更新到本地缓存
        if (!reconcileHashCode.equals(delta.getAppsHashCode()) || clientConfig.shouldLogDeltaDiff()) {
            reconcileAndLogDifference(delta, reconcileHashCode);  // this makes a remoteCall
        }
    } else {
        logger.warn("Not updating application delta as another thread is updating it already");
        logger.debug("Ignoring delta update with apps hashcode {}, as another thread is updating it already", delta.getAppsHashCode());
    }
}

③ 增量注册表合并到本地

再来看下增量注册表合并到本地发方法 updateDelta，其实就是遍历返回来的服务实例，然后根据实例的  ActionType 分别处理，比如前面分析实例注册时 ActionType 就设置了 ADDED，后面分析实例下线时还可以看到设置了 ActionType 为 DELETED。

private void updateDelta(Applications delta) {
    int deltaCount = 0;
    // 变量增量注册的服务
    for (Application app : delta.getRegisteredApplications()) {
        // 遍历实例
        for (InstanceInfo instance : app.getInstances()) {
            Applications applications = getApplications();
            String instanceRegion = instanceRegionChecker.getInstanceRegion(instance);
            if (!instanceRegionChecker.isLocalRegion(instanceRegion)) {
                Applications remoteApps = remoteRegionVsApps.get(instanceRegion);
                if (null == remoteApps) {
                    remoteApps = new Applications();
                    remoteRegionVsApps.put(instanceRegion, remoteApps);
                }
                applications = remoteApps;
            }

            ++deltaCount;
            // ADDED 新增的实例：服务注册
            if (ActionType.ADDED.equals(instance.getActionType())) {
                Application existingApp = applications.getRegisteredApplications(instance.getAppName());
                if (existingApp == null) {
                    applications.addApplication(app);
                }
                logger.debug("Added instance {} to the existing apps in region {}", instance.getId(), instanceRegion);
                applications.getRegisteredApplications(instance.getAppName()).addInstance(instance);
            }
            // MODIFIED 变更的实例：续约，信息变更
            else if (ActionType.MODIFIED.equals(instance.getActionType())) {
                Application existingApp = applications.getRegisteredApplications(instance.getAppName());
                if (existingApp == null) {
                    applications.addApplication(app);
                }
                logger.debug("Modified instance {} to the existing apps ", instance.getId());

                applications.getRegisteredApplications(instance.getAppName()).addInstance(instance);

            }
            // DELETED 移除实例：实例下线、故障
            else if (ActionType.DELETED.equals(instance.getActionType())) {
                Application existingApp = applications.getRegisteredApplications(instance.getAppName());
                if (existingApp != null) {
                    logger.debug("Deleted instance {} to the existing apps ", instance.getId());
                    existingApp.removeInstance(instance);
                    /*
                     * We find all instance list from application(The status of instance status is not only the status is UP but also other status)
                     * if instance list is empty, we remove the application.
                     */
                    if (existingApp.getInstancesAsIsFromEureka().isEmpty()) {
                        applications.removeApplication(existingApp);
                    }
                }
            }
        }
    }
    logger.debug("The total number of instances fetched by the delta processor : {}", deltaCount);

    getApplications().setVersion(delta.getVersion());
    getApplications().shuffleInstances(clientConfig.shouldFilterOnlyUpInstances());

    for (Applications applications : remoteRegionVsApps.values()) {
        applications.setVersion(delta.getVersion());
        applications.shuffleInstances(clientConfig.shouldFilterOnlyUpInstances());
    }
}

④ 客户端实例存储

可以看到，全量更新或者增量更新都是在更新本地的 Applications，可以看下 Applications 和 Application 的结构：

• 应用实例是被封装到 Application 中的，实例列表是一个 LinkedHashSet，并用一个 ConcurrentHashMap 缓存了实例ID和实例的关系，便于快速检索。
• 应用 Application 再被封装到 Applications 中，应用列表是一个 ConcurrentLinkedQueue，并用 ConcurrentHashMap 缓存了应用名称和 Application 的关系。
• Applications 中还保存了这个应用的 appsHashCode  值，这个应该是和 eureka server 的 hash 是一致的。

private final AbstractQueue<Application> applications;
private final Map<String, Application> appNameApplicationMap;
private final Map<String, VipIndexSupport> virtualHostNameAppMap;
private final Map<String, VipIndexSupport> secureVirtualHostNameAppMap;

public Applications(@JsonProperty("appsHashCode") String appsHashCode,
        @JsonProperty("versionDelta") Long versionDelta,
        @JsonProperty("application") List<Application> registeredApplications) {
    // 实例应用队列
    this.applications = new ConcurrentLinkedQueue<Application>();
    // key 为 appName，Value 为对应的应用
    this.appNameApplicationMap = new ConcurrentHashMap<String, Application>();
    this.virtualHostNameAppMap = new ConcurrentHashMap<String, VipIndexSupport>();
    this.secureVirtualHostNameAppMap = new ConcurrentHashMap<String, VipIndexSupport>();
    // hash 值
    this.appsHashCode = appsHashCode;
    this.versionDelta = versionDelta;

    for (Application app : registeredApplications) {
        this.addApplication(app);
    }
}

public class Application {

    private static Random shuffleRandom = new Random();

    private String name;

    // 是否变更
    private volatile boolean isDirty = false;
    // 实例信息
    private final Set<InstanceInfo> instances;

    private final AtomicReference<List<InstanceInfo>> shuffledInstances;
    // map 结构实例
    private final Map<String, InstanceInfo> instancesMap;

    public Application() {
        instances = new LinkedHashSet<InstanceInfo>();
        instancesMap = new ConcurrentHashMap<String, InstanceInfo>();
        shuffledInstances = new AtomicReference<List<InstanceInfo>>();
    }

}

5、Eureka Server 返回增量注册表

① 抓取增量注册表的入口

从前分析知道，增量抓取注册表单接口为 GET/apps/delta，可以很容易找到位于 ApplicationsResource 下的 getContainerDifferential 就是抓取增量注册表的入口。

可以看到，跟抓取注册表类似，也是先构建一个缓存的Key，然后从多级缓存 ResponseCache 中获取。这里的key是 ALL_APPS_DELTA。

@Path("delta")
@GET
public Response getContainerDifferential(
        @PathParam("version") String version,
        @HeaderParam(HEADER_ACCEPT) String acceptHeader,
        @HeaderParam(HEADER_ACCEPT_ENCODING) String acceptEncoding,
        @HeaderParam(EurekaAccept.HTTP_X_EUREKA_ACCEPT) String eurekaAccept,
        @Context UriInfo uriInfo, @Nullable @QueryParam("regions") String regionsStr) {

    Key cacheKey = new Key(Key.EntityType.Application,
            // 增量服务：ALL_APPS_DELTA
            ResponseCacheImpl.ALL_APPS_DELTA,
            keyType, CurrentRequestVersion.get(), EurekaAccept.fromString(eurekaAccept), regions
    );

    final Response response;

    if (acceptEncoding != null && acceptEncoding.contains(HEADER_GZIP_VALUE)) {
         response = Response.ok(responseCache.getGZIP(cacheKey))
                .header(HEADER_CONTENT_ENCODING, HEADER_GZIP_VALUE)
                .header(HEADER_CONTENT_TYPE, returnMediaType)
                .build();
    } else {
        // 从多级缓存中获取增量注册表
        response = Response.ok(responseCache.get(cacheKey)).build();
    }

    CurrentRequestVersion.remove();
    return response;
}

与全量抓取注册表，读取多级缓存的流程都是类似的，唯一的区别就是 Key 不同，全量抓取时是 ALL_APPS，增量抓取时 ALL_APPS_DELTA，区别就在于 readWriteCacheMap 加载数据到缓存中时走的逻辑不一样，可以再看看下面的 generatePayload 方法就知道了。

private Value generatePayload(Key key) {
    Stopwatch tracer = null;
    try {
        String payload;
        switch (key.getEntityType()) {
            case Application:
                boolean isRemoteRegionRequested = key.hasRegions();

                // 获取所有应用
                if (ALL_APPS.equals(key.getName())) {
                    if (isRemoteRegionRequested) {
                        tracer = serializeAllAppsWithRemoteRegionTimer.start();
                        payload = getPayLoad(key, registry.getApplicationsFromMultipleRegions(key.getRegions()));
                    } else {
                        tracer = serializeAllAppsTimer.start();
                        // 从注册表读取所有服务实例
                        payload = getPayLoad(key, registry.getApplications());
                    }
                }
                // 增量获取应用
                else if (ALL_APPS_DELTA.equals(key.getName())) {
                    if (isRemoteRegionRequested) {
                        tracer = serializeDeltaAppsWithRemoteRegionTimer.start();
                        versionDeltaWithRegions.incrementAndGet();
                        versionDeltaWithRegionsLegacy.incrementAndGet();
                        payload = getPayLoad(key,
                                registry.getApplicationDeltasFromMultipleRegions(key.getRegions()));
                    } else {
                        tracer = serializeDeltaAppsTimer.start();
                        versionDelta.incrementAndGet();
                        versionDeltaLegacy.incrementAndGet();
                        // 获取增量注册表
                        payload = getPayLoad(key, registry.getApplicationDeltas());
                    }
                } else {
                    tracer = serializeOneApptimer.start();
                    payload = getPayLoad(key, registry.getApplication(key.getName()));
                }
                break;
            case VIP:
            case SVIP:
                tracer = serializeViptimer.start();
                payload = getPayLoad(key, getApplicationsForVip(key, registry));
                break;
            default:
                logger.error("Unidentified entity type: {} found in the cache key.", key.getEntityType());
                payload = "";
                break;
        }
        return new Value(payload);
    } finally {
        if (tracer != null) {
            tracer.stop();
        }
    }
}

② 增量注册表的设计

之后会调用 registry.getApplicationDeltas() 获取增量注册表，进去可以发现，增量的注册表其实就是 recentlyChangedQueue 这个最近变更队列里的数据，通过遍历 recentlyChangedQueue 生成 Applications。

在返回 apps 之前，先获取了本地所有应用，并计算了一个 hash 值，然后设置到 apps 中。这就和前一节对应起来了，抓取增量注册表时，服务端会返回一个全量注册表的 hash 值，然后客户端将增量注册表合并到本地后，再根据本地的全量注册表计算一个 hash 值，然后将两个 hash 值做对比，如果不一致，说明服务端和客户端的数据是不一致的，这时客户端就会重新向服务端全量拉取注册表到本地。

public Applications getApplicationDeltas() {
    GET_ALL_CACHE_MISS_DELTA.increment();
    Applications apps = new Applications();
    apps.setVersion(responseCache.getVersionDelta().get());
    Map<String, Application> applicationInstancesMap = new HashMap<String, Application>();
    write.lock();
    try {
        // 最近变更队列 recentlyChangedQueue，这就是增量的注册表
        // recentlyChangedQueue 只保留了最近3分钟有变化的实例，如实例上线、下线、故障剔除
        Iterator<RecentlyChangedItem> iter = this.recentlyChangedQueue.iterator();
        logger.debug("The number of elements in the delta queue is : {}",
                this.recentlyChangedQueue.size());
        while (iter.hasNext()) {
            Lease<InstanceInfo> lease = iter.next().getLeaseInfo();
            InstanceInfo instanceInfo = lease.getHolder();
            logger.debug(
                    "The instance id {} is found with status {} and actiontype {}",
                    instanceInfo.getId(), instanceInfo.getStatus().name(), instanceInfo.getActionType().name());
            Application app = applicationInstancesMap.get(instanceInfo
                    .getAppName());
            if (app == null) {
                app = new Application(instanceInfo.getAppName());
                applicationInstancesMap.put(instanceInfo.getAppName(), app);
                apps.addApplication(app);
            }
            app.addInstance(new InstanceInfo(decorateInstanceInfo(lease)));
        }

        // 省略部分代码...

        // 获取所有应用实例
        Applications allApps = getApplications(!disableTransparentFallback);
        // 根据所有应用实例计算一个 hash 值，并设置到要返回的 apps 中
        apps.setAppsHashCode(allApps.getReconcileHashCode());
        return apps;
    } finally {
        write.unlock();
    }
}

再来看看 recentlyChangedQueue 是如何设计来保存增量信息的。

再看看前面提到过的注册表初始化的构造方法，最后创建了一个每隔30秒执行一次的定时调度任务。这个任务会遍历 recentlyChangedQueue 这个队列，判断每个元素的最后更新时间是否超过了 180 秒，如果超过了，就会从队列中移除这个元素。超过 180 秒的实例变更信息，就会认为这些变更信息都已经同步到客户端了，因为客户端是每隔30秒拉取一次增量注册表的。因此客户端多次拉取增量注册表可能拉取到同样的变更信息，不过最终合并到本地都是一样的。

因此可以看出，eureka 利用 recentlyChangedQueue 这个最近变更队列保存了最近3分钟以内实例的变更信息，如新服务注册、服务下线等，然后客户端每次就是拉取这个变更队列。

protected AbstractInstanceRegistry(EurekaServerConfig serverConfig, EurekaClientConfig clientConfig, ServerCodecs serverCodecs) {
    this.serverConfig = serverConfig;
    this.clientConfig = clientConfig;
    this.serverCodecs = serverCodecs;
    // 最近下线的循环队列
    this.recentCanceledQueue = new CircularQueue<Pair<Long, String>>(1000);
    // 最近注册的循环队列
    this.recentRegisteredQueue = new CircularQueue<Pair<Long, String>>(1000);

    // 最近一分钟续约的计数器
    this.renewsLastMin = new MeasuredRate(1000 * 60 * 1);

    // 一个定时调度任务，定时剔除最近改变队列中过期的实例
    this.deltaRetentionTimer.schedule(getDeltaRetentionTask(),
            // 调度任务延迟 30 秒开始执行
            serverConfig.getDeltaRetentionTimerIntervalInMs(),
            // 默认每隔 30 秒执行一次
            serverConfig.getDeltaRetentionTimerIntervalInMs());
}

/////////////////////////////////////////

private TimerTask getDeltaRetentionTask() {
    return new TimerTask() {

        @Override
        public void run() {
            // 最近变更的队列
            Iterator<RecentlyChangedItem> it = recentlyChangedQueue.iterator();
            while (it.hasNext()) {
                // 最近更新时间超过 180 秒就认为数据已经同步到各个客户端了，就从队列中移除
                if (it.next().getLastUpdateTime() <
                        // retentionTimeInMSInDeltaQueue：delta队列数据保留时间，默认 180 秒
                        System.currentTimeMillis() - serverConfig.getRetentionTimeInMSInDeltaQueue()) {
                    it.remove();
                } else {
                    break;
                }
            }
        }

    };
}

7、Eureka 抓取注册表总体流程图

下面还是用一张图整体展示下服务抓取注册表的整理流程。

服务注册、服务下线、实例故障剔除都会将读写缓存 readWriteCacheMap 中对应的实例失效掉，然后加入到最近变更队列 recentlyChangedQueue 中，因此这三种情况下，增量抓取注册表的逻辑都是类似的。

七、服务续约

在分布式系统中，服务续约机制是非常重要的，这样能让中心系统（注册中心）知道客户端还存活着。接下来就来看看服务续约的机制。

1、Eureka Client 定时发送心跳

在初始化 DiscoveryClient 的调度任务时，下面这部分代码就是在创建定时发送心跳的任务，心跳每隔30秒发送一次。发送心跳的接口是 PUT /apps/{appName}/{instanceId}。

private void initScheduledTasks() {
    // 定时刷新本地缓存...

    if (clientConfig.shouldRegisterWithEureka()) {
        // 续约间隔时间，默认30秒
        int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
        // 心跳调度器的延迟时间扩大倍数，默认10
        int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
        logger.info("Starting heartbeat executor: " + "renew interval is: {}", renewalIntervalInSecs);

        // 心跳的定时任务
        heartbeatTask = new TimedSupervisorTask(
                "heartbeat",
                scheduler,
                heartbeatExecutor,
                renewalIntervalInSecs,
                TimeUnit.SECONDS,
                expBackOffBound,
                new HeartbeatThread()
        );
        // 30秒后开始调度心跳的任务
        scheduler.schedule(
                heartbeatTask,
                renewalIntervalInSecs, TimeUnit.SECONDS);

        // 服务注册...
    } else {
        logger.info("Not registering with Eureka server per configuration");
    }
}

//////////////////////////////////////////////

private class HeartbeatThread implements Runnable {
    public void run() {
        if (renew()) {
            lastSuccessfulHeartbeatTimestamp = System.currentTimeMillis();
        }
    }
}

//////////////////////////////////////////////

boolean renew() {
    EurekaHttpResponse<InstanceInfo> httpResponse;
    try {
        // 发送心跳的接口：PUT /apps/{appName}/{instanceId}
        httpResponse = eurekaTransport.registrationClient.sendHeartBeat(instanceInfo.getAppName(), instanceInfo.getId(), instanceInfo, null);
        logger.debug(PREFIX + "{} - Heartbeat status: {}", appPathIdentifier, httpResponse.getStatusCode());
        if (httpResponse.getStatusCode() == Status.NOT_FOUND.getStatusCode()) {
            REREGISTER_COUNTER.increment();
            logger.info(PREFIX + "{} - Re-registering apps/{}", appPathIdentifier, instanceInfo.getAppName());
            long timestamp = instanceInfo.setIsDirtyWithTime();
            // 服务端未找到对应的实例，就重新注册
            boolean success = register();
            if (success) {
                instanceInfo.unsetIsDirty(timestamp);
            }
            return success;
        }
        // 续约成功
        return httpResponse.getStatusCode() == Status.OK.getStatusCode();
    } catch (Throwable e) {
        logger.error(PREFIX + "{} - was unable to send heartbeat!", appPathIdentifier, e);
        return false;
    }
}

2、Eureka Server 接收心跳续约

顺着 PUT /apps/{appName}/{instanceId} 找可以发现，服务端接收注册的入口在 InstanceResource 的 renewLease 方法中，它调用了注册表单 renew 方法进行服务续约。

@PUT
public Response renewLease(
        @HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication,
        @QueryParam("overriddenstatus") String overriddenStatus,
        @QueryParam("status") String status,
        @QueryParam("lastDirtyTimestamp") String lastDirtyTimestamp) {
    boolean isFromReplicaNode = "true".equals(isReplication);
    // 调用注册表的 renew 进行服务续约
    boolean isSuccess = registry.renew(app.getName(), id, isFromReplicaNode);

    // Not found in the registry, immediately ask for a register
    if (!isSuccess) {
        logger.warn("Not Found (Renew): {} - {}", app.getName(), id);
        return Response.status(Status.NOT_FOUND).build();
    }
    // Check if we need to sync based on dirty time stamp, the client
    // instance might have changed some value
    Response response;
    if (lastDirtyTimestamp != null && serverConfig.shouldSyncWhenTimestampDiffers()) {
        response = this.validateDirtyTimestamp(Long.valueOf(lastDirtyTimestamp), isFromReplicaNode);
        // Store the overridden status since the validation found out the node that replicates wins
        if (response.getStatus() == Response.Status.NOT_FOUND.getStatusCode()
                && (overriddenStatus != null)
                && !(InstanceStatus.UNKNOWN.name().equals(overriddenStatus))
                && isFromReplicaNode) {
            registry.storeOverriddenStatusIfRequired(app.getAppName(), id, InstanceStatus.valueOf(overriddenStatus));
        }
    } else {
        response = Response.ok().build();
    }
    logger.debug("Found (Renew): {} - {}; reply status={}", app.getName(), id, response.getStatus());
    return response;
}

进去可以看到，调用了父类的 renew 方法续约，然后会判断 isReplication ，如果是复制，说明是来自 eureka-server 集群中其它节点的同步请求，就复制到其它节点。复制到其它集群这块代码在前面已经提到过了，就不再展示。

public boolean renew(final String appName, final String id, final boolean isReplication) {
    // 调用父类（AbstractInstanceRegistry）的 renew 续约
    if (super.renew(appName, id, isReplication)) {
        // 续约完成后同步到集群其它节点
        replicateToPeers(Action.Heartbeat, appName, id, null, null, isReplication);
        return true;
    }
    return false;
}

接着看父类的 renew 续约方法：

• 首先根据服务名从注册表中取出租约信息
• 然后根据实例ID取出实例的租约信息
• 然后判断是否是覆盖实例状态
• 将最近一分钟续约次数计数器 renewsLastMin +1
• 最后调用实例租约对象的 renew 方法进行续约，其内部只是更新了租约的最后更新时间 lastUpdateTimestamp ，更新为当前时间+续约间隔时间。

public boolean renew(String appName, String id, boolean isReplication) {
    RENEW.increment(isReplication);
    // 根据服务名从注册表取出租约信息
    Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
    Lease<InstanceInfo> leaseToRenew = null;
    if (gMap != null) {
        // 根据实例ID取出实例租约信息
        leaseToRenew = gMap.get(id);
    }
    if (leaseToRenew == null) {
        RENEW_NOT_FOUND.increment(isReplication);
        logger.warn("DS: Registry: lease doesn't exist, registering resource: {} - {}", appName, id);
        return false;
    } else {
        InstanceInfo instanceInfo = leaseToRenew.getHolder();
        if (instanceInfo != null) {
            // touchASGCache(instanceInfo.getASGName());
            InstanceStatus overriddenInstanceStatus = this.getOverriddenInstanceStatus(
                    instanceInfo, leaseToRenew, isReplication);
            if (overriddenInstanceStatus == InstanceStatus.UNKNOWN) {
                logger.info("Instance status UNKNOWN possibly due to deleted override for instance {}"
                        + "; re-register required", instanceInfo.getId());
                RENEW_NOT_FOUND.increment(isReplication);
                return false;
            }
            if (!instanceInfo.getStatus().equals(overriddenInstanceStatus)) {
                logger.info(
                        "The instance status {} is different from overridden instance status {} for instance {}. "
                                + "Hence setting the status to overridden status", instanceInfo.getStatus().name(),
                                overriddenInstanceStatus.name(),
                                instanceInfo.getId());
                instanceInfo.setStatusWithoutDirty(overriddenInstanceStatus);

            }
        }
        // 最近一分钟续约计数器+1
        renewsLastMin.increment();
        // 续约
        leaseToRenew.renew();
        return true;
    }
}

////////////////////////////////////////////////

public void renew() {
    // 更新最后更新时间，在当前时间的基础上加了周期时间，默认90秒
    lastUpdateTimestamp = System.currentTimeMillis() + duration;
}

八、服务下线

1、Eureka Client 下线

eureka client 服务关闭停止时，会触发 DiscoveryClient 的 shutdown 关闭 eureka-client，我们就从 shutdown 方法来看看 eureka-client 的下线。

• 首先移除了注册的状态变更器，这个时候不再需要监听实例状态的变更了
• 然后关闭了一系列的调度任务，停止与 eureka-server 的交互，比如定时发送心跳。同时也释放了资源。
• 之后调用了 unregister 取消注册，其实就是调用了 server 端的 DELETE /apps/{appName}/{instanceId} 下线实例
• 最后再关闭了一些其它资源，如 EurekaTransport。

@PreDestroy
@Override
public synchronized void shutdown() {
    if (isShutdown.compareAndSet(false, true)) {
        logger.info("Shutting down DiscoveryClient ...");

        // 移除状态变更监听器
        if (statusChangeListener != null && applicationInfoManager != null) {
            applicationInfoManager.unregisterStatusChangeListener(statusChangeListener.getId());
        }

        // 停止调度任务，释放资源：
        //    instanceInfoReplicator、heartbeatExecutor、cacheRefreshExecutor
        //    scheduler、cacheRefreshTask、heartbeatTask
        cancelScheduledTasks();

        // If APPINFO was registered
        if (applicationInfoManager != null
                && clientConfig.shouldRegisterWithEureka()
                && clientConfig.shouldUnregisterOnShutdown()) {
            applicationInfoManager.setInstanceStatus(InstanceStatus.DOWN);
            // 调用 eureka-server 的下线接口下线实例
            unregister();
        }

        // 继续释放资源
        if (eurekaTransport != null) {
            eurekaTransport.shutdown();
        }
        heartbeatStalenessMonitor.shutdown();
        registryStalenessMonitor.shutdown();

        Monitors.unregisterObject(this);

        logger.info("Completed shut down of DiscoveryClient");
    }
}

void unregister() {
    // It can be null if shouldRegisterWithEureka == false
    if(eurekaTransport != null && eurekaTransport.registrationClient != null) {
        try {
            logger.info("Unregistering ...");
            // 取消注册：DELETE /apps/{appName}/{instanceId}
            EurekaHttpResponse<Void> httpResponse = eurekaTransport.registrationClient.cancel(instanceInfo.getAppName(), instanceInfo.getId());
            logger.info(PREFIX + "{} - deregister  status: {}", appPathIdentifier, httpResponse.getStatusCode());
        } catch (Exception e) {
            logger.error(PREFIX + "{} - de-registration failed{}", appPathIdentifier, e.getMessage(), e);
        }
    }
}

2、Eureka Server 服务下线

顺着 DELETE /apps/{appName}/{instanceId} 接口可以找到 InstanceResouce 的 cancelLease 方法就是客户端下线的入口。

进入注册的 cancel 方法，可以看到与前面的一些接口是类似的，先调用服务的 cancel 方法下线实例，然后调用 replicateToPeers 复制到集群中其它节点。然后 cancel 方法其实是调用的 internalCancel 方法。

@DELETE
public Response cancelLease(@HeaderParam(PeerEurekaNode.HEADER_REPLICATION) String isReplication) {
    try {
        // 下线实例
        boolean isSuccess = registry.cancel(app.getName(), id,
            "true".equals(isReplication));

        if (isSuccess) {
            logger.debug("Found (Cancel): {} - {}", app.getName(), id);
            return Response.ok().build();
        } else {
            logger.info("Not Found (Cancel): {} - {}", app.getName(), id);
            return Response.status(Status.NOT_FOUND).build();
        }
    } catch (Throwable e) {
        logger.error("Error (cancel): {} - {}", app.getName(), id, e);
        return Response.serverError().build();
    }
}

//////////////////////////////////////////

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);

        return true;
    }
    return false;
}

//////////////////////////////////////////

public boolean cancel(String appName, String id, boolean isReplication) {
    return internalCancel(appName, id, isReplication);
}

再来看下 internalCancel 方法：

• 首先根据服务名从注册表取出服务所有实例的租约信息，再根据实例ID移除实例租约信息
• 将移除的实例加入到最近下线的一个循环队列 recentCanceledQueue
• 下线实例，注意这里设置了实例的下线时间 evictionTimestamp 为当前时间
• 然后设置实例的 ActionType 为 DELETED，再将下线的实例加入最近变更的队列 recentlyChangedQueue
• 之后失效掉缓存 readWriteCacheMap，服务实例变更了就必须清理缓存。不过  readWriteCacheMap 可能要30秒才会同步到 readOnlyCacheMap。
• 最后将期望续约的客户端数量-1，然后更新了每分钟续约次数阈值

protected boolean internalCancel(String appName, String id, boolean isReplication) {
    read.lock();
    try {
        CANCEL.increment(isReplication);
        // 根据服务名称取出服务租约信息
        Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
        Lease<InstanceInfo> leaseToCancel = null;
        if (gMap != null) {
            // 根据实例ID移除实例租约信息
            leaseToCancel = gMap.remove(id);
        }
        // 将移除的实例ID加入到最近下线的队列中
        recentCanceledQueue.add(new Pair<Long, String>(System.currentTimeMillis(), appName + "(" + id + ")"));
        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 {
            // 下线实例，设置了实例的下线时间 evictionTimestamp 为当前时间戳
            leaseToCancel.cancel();
            InstanceInfo instanceInfo = leaseToCancel.getHolder();
            String vip = null;
            String svip = null;
            if (instanceInfo != null) {
                // 设置实例 ActionType 为 DELETED
                instanceInfo.setActionType(ActionType.DELETED);
                // 加入最近变更队列中
                recentlyChangedQueue.add(new RecentlyChangedItem(leaseToCancel));
                instanceInfo.setLastUpdatedTimestamp();
                vip = instanceInfo.getVIPAddress();
                svip = instanceInfo.getSecureVipAddress();
            }
            // 失效缓存
            invalidateCache(appName, vip, svip);
            logger.info("Cancelled instance {}/{} (replication={})", appName, id, isReplication);
        }
    } finally {
        read.unlock();
    }

    synchronized (lock) {
        // 期望续约的客户端数量 - 1
        if (this.expectedNumberOfClientsSendingRenews > 0) {
            // Since the client wants to cancel it, reduce the number of clients to send renews.
            this.expectedNumberOfClientsSendingRenews = this.expectedNumberOfClientsSendingRenews - 1;
            // 更新每分钟续约次数的阈值
            updateRenewsPerMinThreshold();
        }
    }

    return true;
}

九、服务故障

服务正常停止时，会触发 DiscoveryClient 的 shutdown 方法关闭 eureka-client，并向注册中心发送下线的通知。但如果客户端宕机或非正常关机，注册中心就无法接收到客户端下线的通知了，这时注册中心就会有一个定时任务，根据心跳来判断客户端实例是否故障下线了，然后摘除故障的实例。

1、摘除实例的定时任务初始化

在 EurekaBootStrap 初始化的最后几步中，调用了注册表的 openForTraffic 做一些最后的设置，其中最后一步调用了 super.postInit 方法做最后的初始化，里面就创建了定时摘除过期实例的调度任务。

registry.openForTraffic(applicationInfoManager, registryCount);

public void openForTraffic(ApplicationInfoManager applicationInfoManager, int count) {
    // 期望的客户端每分钟的续约次数
    this.expectedNumberOfClientsSendingRenews = count;
    // 更新每分钟续约阈值
    updateRenewsPerMinThreshold();
    logger.info("Got {} instances from neighboring DS node", count);
    logger.info("Renew threshold is: {}", numberOfRenewsPerMinThreshold);
    this.startupTime = System.currentTimeMillis();
    if (count > 0) {
        this.peerInstancesTransferEmptyOnStartup = false;
    }
    DataCenterInfo.Name selfName = applicationInfoManager.getInfo().getDataCenterInfo().getName();
    boolean isAws = Name.Amazon == selfName;
    if (isAws && serverConfig.shouldPrimeAwsReplicaConnections()) {
        logger.info("Priming AWS connections for all replicas..");
        primeAwsReplicas(applicationInfoManager);
    }
    logger.info("Changing status to UP");
    // 设置实例状态为已启动
    applicationInfoManager.setInstanceStatus(InstanceStatus.UP);
    // 调用父类的后置初始化
    super.postInit();
}

postInit：

• 首先是开启了最近一分钟续约次数的计数器
• 然后创建了定时摘除过期实例的调度任务，调度任务每隔60秒执行一次

protected void postInit() {
    // 启动 统计最近一分钟续约次数的计数器
    renewsLastMin.start();
    if (evictionTaskRef.get() != null) {
        evictionTaskRef.get().cancel();
    }
    // 定时剔除任务
    evictionTaskRef.set(new EvictionTask());
    evictionTimer.schedule(evictionTaskRef.get(),
            serverConfig.getEvictionIntervalTimerInMs(),
            // 每隔60秒执行一次
            serverConfig.getEvictionIntervalTimerInMs());
}

2、定时摘除过期的实例

① 摘除实例的定时任务

可以看到，每次运行摘除实例的任务时，会先获取一个补偿时间，因为两次 EvictionTask 执行的间隔时间可能超过了设置的60秒，比如 GC 导致的停顿或本地时间漂移导致计时不准确等。然后就调用了 evict 方法摘除实例。

在计算时间差的场景中，这种补偿时间的思路是值得学习的，要考虑到时间差的不准确性。

class EvictionTask extends TimerTask {

    private final AtomicLong lastExecutionNanosRef = new AtomicLong(0l);

    @Override
    public void run() {
        try {
            // 获取补偿时间，因为两次 EvictionTask 执行的间隔时间可能超过了设置的60秒，比如 GC 导致的停顿或本地时间漂移导致计时不准确
            long compensationTimeMs = getCompensationTimeMs();
            logger.info("Running the evict task with compensationTime {}ms", compensationTimeMs);
            evict(compensationTimeMs);
        } catch (Throwable e) {
            logger.error("Could not run the evict task", e);
        }
    }

    long getCompensationTimeMs() {
        long currNanos = getCurrentTimeNano();
        long lastNanos = lastExecutionNanosRef.getAndSet(currNanos);
        if (lastNanos == 0L) {
            return 0L;
        }
        // 两次任务运行的间隔时间
        long elapsedMs = TimeUnit.NANOSECONDS.toMillis(currNanos - lastNanos);
        // 补偿时间 = 任务运行间隔时间 - 剔除任务的间隔时间（默认60秒）
        long compensationTime = elapsedMs - serverConfig.getEvictionIntervalTimerInMs();
        return compensationTime <= 0L ? 0L : compensationTime;
    }

    long getCurrentTimeNano() {  // for testing
        return System.nanoTime();
    }
}

② 摘除实例

摘除实例的过程如下：

• 首先判断是否启用了租约过期的机制（主要就是自我保护机制，下一章节再说）。
• 遍历注册表，判断实例是否过期，将过期的实例加入集合列表中。
• 计算摘除实例的数量限制，主要就是出于自我保护机制，避免一次摘除过多实例。
• 然后就是从要摘除的集合中随机选择限制数量内的过期实例来摘除掉。
• 摘除实例其实就是调用了实例下线的方法 internalCancel，主要就是从注册表中移除实例、加入最近变更的队列、失效缓存等，具体可以回看服务下线那节。

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

    // 是否启用了租约过期
    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();
                // 判断实例租约是否过期
                if (lease.isExpired(additionalLeaseMs) && lease.getHolder() != null) {
                    // 加入到过期的集合列表中
                    expiredLeases.add(lease);
                }
            }
        }
    }

    // 先获取注册表已注册的实例数量
    int registrySize = (int) getLocalRegistrySize();
    // 注册表数量保留的阈值：已注册的实例数 * 续约百分比阈值（默认0.85）
    int registrySizeThreshold = (int) (registrySize * serverConfig.getRenewalPercentThreshold());
    // 剔除的数量限制，也就是说一次最多只能剔除 15% 的实例
    int evictionLimit = registrySize - registrySizeThreshold;

    // 得到最小的剔除数量
    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++) {
            // 根据要剔除的数量从 expiredLeases 中随机剔除 toEvict 个过期实例
            int next = i + random.nextInt(expiredLeases.size() - i);
            Collections.swap(expiredLeases, i, next);
            Lease<InstanceInfo> lease = expiredLeases.get(i);

            String appName = lease.getHolder().getAppName();
            // 实例ID
            String id = lease.getHolder().getId();
            EXPIRED.increment();
            logger.warn("DS: Registry: expired lease for {}/{}", appName, id);
            // 调用下线的方法
            internalCancel(appName, id, false);
        }
    }
}

③ 分批次摘取实例

可以看到，过期的实例并不是一次性摘除的，而是计算了一个阈值 toEvict，一次只随机摘除 toEvict 个过期实例，采用了分批摘取+随机摘取的机制。

比如注册表一共有20个实例，那么最多可以摘除的实例数 toEvict = 20 - 20 * 0.85 = 3 个，也就是说就算有5个实例过期了，那这一次也只能随机摘除其中3个，另外两个要等到下一次执行摘除任务时再摘除。

这种分批摘取机制+随机摘取机制可能会导致有些过期实例要过很久才能下线，尤其是在开发环境这种频繁启动、停止服务的场景中。

3、如何判断实例是否过期

从上面可以看到，eureka 调用了 lease.isExpired(additionalLeaseMs) 来判断实例是否过期。进入 isExpired 这个方法可以看到，如果已经设置了摘除时间，或者 当前时间 > （实例最后更新时间 + 续约周期(90秒) + 补偿时间），就认为实例已经过期了，说明实例已经超过一个周期没有续约了，就认为这个客户端实例发生了故障，无法续约，要被摘除掉。

/**
 * Checks if the lease of a given {@link com.netflix.appinfo.InstanceInfo} has expired or not.
 *
 * Note that due to renew() doing the 'wrong" thing and setting lastUpdateTimestamp to +duration more than
 * what it should be, the expiry will actually be 2 * duration. This is a minor bug and should only affect
 * instances that ungracefully shutdown. Due to possible wide ranging impact to existing usage, this will
 * not be fixed.
 *
 * @param additionalLeaseMs any additional lease time to add to the lease evaluation in ms.
 */
public boolean isExpired(long additionalLeaseMs) {
    // 已经设置过剔除时间，或者 当前时间 > （实例最后更新时间 + 续约周期(90秒) + 补偿时间）
    return (evictionTimestamp > 0 || System.currentTimeMillis() > (lastUpdateTimestamp + duration + additionalLeaseMs));
}

这里其实要注意的是另外一个问题，可以看看 isExpired 的注释，eureka 说这其实是一个bug，但不打算修复了，因为它的 duration 其实是被加了两次的，下面来看看怎么回事。

先看下 lastUpdateTimestamp 是如何更新的，在客户端续约的时候会更新 lastUpdateTimestamp，将其设置为 当前时间 + duration 间隔周期（默认90秒），

public void renew() {
    // 更新最后更新时间，在当前时间的基础上加了一个周期间隔时间，默认90秒
    lastUpdateTimestamp = System.currentTimeMillis() + duration;
}

这个 duration 在注册的时候也有设置，我们通过这个来看看它的含义是什么。可以看到，如果客户端没有配置 durationInSecs，就会设置为默认的 90 秒。

从 getDurationInSecs 的注释可以看出，这个 duration 的意思是等待客户端多久没有续约之后就将其剔除，默认为 90 秒。比如客户端每隔 30 秒续约一次，那可能超过3次没有续约之后，就会认为客户端实例故障了，就要将其摘除掉。

public void register(final InstanceInfo info, final boolean isReplication) {
    int leaseDuration = Lease.DEFAULT_DURATION_IN_SECS;
    // 如果实例中没有周期的配置，就设置为默认的 90 秒
    if (info.getLeaseInfo() != null && info.getLeaseInfo().getDurationInSecs() > 0) {
        leaseDuration = info.getLeaseInfo().getDurationInSecs();
    }
    // 注册实例
    super.register(info, leaseDuration, isReplication);
    // 复制到集群其它 server 节点
    replicateToPeers(Action.Register, info.getAppName(), info.getId(), info, null, isReplication);
}

//////////////////////////////////////////////

/**
 * Returns client specified setting for eviction (e.g. how long to wait w/o
 * renewal event)
 *
 * @return time in milliseconds since epoch.
 */
public int getDurationInSecs() {
    return durationInSecs;
}

但实际上并不是90秒后摘除实例，可以看到 isExpired 里面将 lastUpdateTimestamp 又加了一个 duration，也就是 180 秒了。也就是说客户端实例超过 180 秒未续约才被认为是故障了，然后要将其摘除。

isExpired 的注释也说了，续约的方法 renew() 错误的计算了 lastUpdateTimestamp，实际的过期周期是 2 * duration，但是 eureka 并不打算修复这个bug，因为它的影响范围很小。

所以这里得出一个结论，客户端关闭了（非正常下线），注册表中的实例并不是90秒后就摘除了，至少是 180 秒后才会被摘除。

十、自我保护机制

如果网段偶尔抖动或暂时不可用，就无法接收到客户端的续约，因此 eureka server 为了保证可用性，就会去判断最近一分钟收到的心跳次数是否小于指定的阈值，是的就会触发自我保护机制，关闭租约失效剔除，不再摘除实例，从而保护注册信息。

1、摘除实例时的自我保护机制

摘除实例的 evict 方法调用了 isLeaseExpirationEnabled 这个方法判断是否触发自我保护机制，如果返回 false，就不会摘除实例了。

先看看 isLeaseExpirationEnabled 这个方法：

• 首先，如果没有启用自我保护机制，就返回 true，那就可以摘除实例
• 如果启用了自我保护机制（默认启用），就判断每分钟续约阈值 > 0 且 最近一分钟续约次数 > 每分钟续约阈值 就是启用了租约过期

public boolean isLeaseExpirationEnabled() {
    // 先判断是否启用了自我保护机制
    if (!isSelfPreservationModeEnabled()) {
        // The self preservation mode is disabled, hence allowing the instances to expire.
        return true;
    }
    // 每分钟续约阈值大于0, 且 最近一分钟续约次数 大于 每分钟续约阈值
    return numberOfRenewsPerMinThreshold > 0 && getNumOfRenewsInLastMin() > numberOfRenewsPerMinThreshold;
}

public boolean isSelfPreservationModeEnabled() {
    return serverConfig.shouldEnableSelfPreservation();
}

这个每分钟续约阈值 numberOfRenewsPerMinThreshold 在前面很多地方都看到过了，服务注册、下线、openForTraffic、以及有个定时任务每隔15分钟都会调用下面这个方法来更新 numberOfRenewsPerMinThreshold。

protected void updateRenewsPerMinThreshold() {
    // 每分钟续约阈值 = 期望续约的客户端数量 * （60 / 续约间隔时间） * 续约阈值
    // 例如，一共注册了 10 个实例，那么期望续约的客户端数量为 10，间隔时间默认为 30秒，就是每个客户端应该每30秒发送一次心跳，续约百分比默认为 0.85
    // 每分钟续约次数阈值 = 10 * (60.0 / 30) * 0.85 = 17，也就是说每分钟至少要接收到 17 此续约请求
    this.numberOfRenewsPerMinThreshold = (int) (this.expectedNumberOfClientsSendingRenews
            * (60.0 / serverConfig.getExpectedClientRenewalIntervalSeconds())
            * serverConfig.getRenewalPercentThreshold());
}

expectedNumberOfClientsSendingRenews 在实例注册的时候会 + 1，在实例下线的时候会 - 1，其代表的就是期望续约的客户端数量。

/////////////// 实例注册 ///////////////
synchronized (lock) {
    if (this.expectedNumberOfClientsSendingRenews > 0) {
        // Since the client wants to register it, increase the number of clients sending renews
        // 期望续约的客户端数量 + 1
        this.expectedNumberOfClientsSendingRenews = this.expectedNumberOfClientsSendingRenews + 1;
        // 更新每分钟续约请求次数的阈值，这个阈值在后面很多地方都会用到
        updateRenewsPerMinThreshold();
    }
}


/////////////// 实例下线（下线、故障摘除） ///////////////
synchronized (lock) {
    // 期望续约的客户端数量 - 1
    if (this.expectedNumberOfClientsSendingRenews > 0) {
        // Since the client wants to cancel it, reduce the number of clients to send renews.
        this.expectedNumberOfClientsSendingRenews = this.expectedNumberOfClientsSendingRenews - 1;
        // 更新每分钟续约次数的阈值
        updateRenewsPerMinThreshold();
    }
}

而最近一分钟续约次数计数器 renewsLastMin 在每个客户端续约的时候就会+1，可以回看下 renew 方法，最后调用了 renewsLastMin.increment() 增加一次续约次数。而 renewsLastMin.getCount() 返回的是上一分钟总的续约次数。

public long getNumOfRenewsInLastMin() {
    return renewsLastMin.getCount();
}

根据以上代码举个例子来看看实例故障时的自我保护机制：

• 比如注册了20个实例，实例默认发送心跳续约的间隔时间为30秒，续约的阈值为 0.85，并且开启了自我保护机制。
• 那么期望续约的客户端数量 expectedNumberOfClientsSendingRenews = 20，每分钟发送心跳的阈值 numberOfRenewsPerMinThreshold = 20 * （60 / 30 ）* 0.85 = 34。
• 正常来说20个实例每分钟发送心跳的次数 renewsLastMin = 20 * （60 / 30）= 40 次。
• 那么 numberOfRenewsPerMinThreshold（34） > 0 && renewsLastMin（40）> numberOfRenewsPerMinThreshold（34）就是满足的，就允许摘除故障的实例。
• 那如果有 3 个实例上一分钟没有发送续约了，这个时候 renewsLastMin = 17 * （60 / 30）= 34 次，而 numberOfRenewsPerMinThreshold 还是不变，因为注册表的实例并未移除，因此这时条件就不满足了，就算实例真的故障了，也不能摘除实例了。

这就是 eureka-server 的自我保护机制，他认为如果短时间内有过的的实例未发送心跳（超过15%），它会认为是自己网络故障导致客户端不能发送心跳，就进入自我保护机制，避免误摘除实例。

2、自我保护机制导致实例未下线的情况

在开发环境中，因为会频繁重启服务，会发现有些服务已经是下线状态了（DOWN），但服务实例一直未被摘除，就是因为 eureka-server 的自我保护机制导致的，下面来看下。

① 启用自我保护机制的情况

首先 eureka-server 做了如下配置，启用注册中心：

eureka:
  server:
    # 是否启用自我保护机制
    enable-self-preservation: true

启动几个客户端实例：

然后快速将 demo-consumer 停止掉（如果正常关闭，会调用 cancel 下线实例），这时就会看到 demo-consumer 已经DOWN了，但是实例一直未被移除。

可以看到，上一分钟续约的次数为 4 次，期望每分钟续约次数为6次，因为不满足判断的条件，所以就触发了自我保护机制，导致一直无法摘除实例。

注意期望续约的客户端数量为4，而实际注册的客户端实例是3个，这是因为 springcloud 在调用 openForTraffic 设置了初始值为 1。

② 关闭自我保护机制的情况

配置如下，关闭自我保护机制：

eureka:
  server:
    # 是否启用自我保护机制
    enable-self-preservation: false

这时注册中心控制台会提示我们关闭了自我保护机制：

同样的操作，快速停掉实例，发现实例还是未被摘除：

那其实是因为实例要180秒后才会被认为是过期的，所以等3分钟以后，实例就会下线了。

public boolean isExpired(long additionalLeaseMs) {
    return (evictionTimestamp > 0 || System.currentTimeMillis() > (lastUpdateTimestamp + duration + additionalLeaseMs));
}

③ 快速关闭多个实例

这次同时关闭2个实例来看看，在2分钟之后，发现只有一个实例下线了，这因为eureka-server一次只会摘除15%的实例。

④ DOWN 是怎么来的

那么DOWN这个状态是怎么来的呢？由于我本地是用IDEA启动的客户端实例，其实在关闭的时候，会触发状态变更监听器，然后就会触发一次注册的调用，注册的状态是 DOWN，因此实例状态马上就变为 DOWN 了。

如果直接 kill 这个进程，就不会触发状态变更监听器了，注册中心的实例就不会变为 DOWN 了，但是实例已经下线变为不可用的状态了。

⑤ 实例快速下线

经过前面的测试可以总结出来，要想实例快速下线，可以调整如下一些参数。

eureka-server 配置：

eureka:
  server:
    # 是否启用自我保护机制
    enable-self-preservation: false
    # 每分钟续约阈值
    renewal-percent-threshold: 0
    # 摘除实例的定时任务的间隔时间
    eviction-interval-timer-in-ms: 10000

eureka-client 配置：

eureka:
  instance:
    # 判断实例多久未发送心跳就判定为过期
    lease-expiration-duration-in-seconds: 60

3、最近一分钟计数器的设计

来看下最近一分钟续约次数计数器 renewsLastMin 是如何统计上一分钟的续约次数的，renewsLastMin 的类型是 MeasuredRate，这个类的设计也是值得学习的一个点。

MeasuredRate 利用两个桶来计数，一个保存上一间隔时间的计数，一个保存当前这一间隔时间的计数，然后使用定时任务每隔一定间隔时间就将当前这个桶的计数替换到上一个桶里。然后增加计数的时候增加当前桶，获取数量的时候从上一个桶里获取，就实现了获取上一个间隔时间的计数。

public class MeasuredRate {
    private static final Logger logger = LoggerFactory.getLogger(MeasuredRate.class);
    // 利用了两个桶来计数，一个是上一分钟，一个是当前这一分钟
    private final AtomicLong lastBucket = new AtomicLong(0);
    private final AtomicLong currentBucket = new AtomicLong(0);

    private final long sampleInterval;
    private final Timer timer;

    private volatile boolean isActive;

    /**
     * @param sampleInterval in milliseconds
     */
    public MeasuredRate(long sampleInterval) {
        // 间隔时间
        this.sampleInterval = sampleInterval;
        // 定时器
        this.timer = new Timer("Eureka-MeasureRateTimer", true);
        this.isActive = false;
    }

    public synchronized void start() {
        if (!isActive) {
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    try {
                        // 每分钟执行一次，将当前这一分钟的次数设置到上一分钟的桶里
                        lastBucket.set(currentBucket.getAndSet(0));
                    } catch (Throwable e) {
                        logger.error("Cannot reset the Measured Rate", e);
                    }
                }
            }, sampleInterval, sampleInterval);

            isActive = true;
        }
    }

    public synchronized void stop() {
        if (isActive) {
            timer.cancel();
            isActive = false;
        }
    }

    /**
     * Returns the count in the last sample interval.
     */
    public long getCount() {
        // 获取计数时是获取的上一分钟这个桶的计数
        return lastBucket.get();
    }

    /**
     * Increments the count in the current sample interval.
     */
    public void increment() {
        // 增加计数的时候是增加的当前这个桶的计数
        currentBucket.incrementAndGet();
    }
}

4、服务故障摘除和自我保护机制图

下面用一张图来总结下服务故障摘除和自我保护机制。