深入理解Eureka-Client 发送心跳（三），

自己的理解：

Eureka的心跳作用就是為了最後的保護機制和服务的自我剔除。首先會根據心跳更新續約時間，然後根據續約時間來判斷服務是否過期，最後根據服務是否過期來剔除服務。在剔除服务之前会判断服务是否自我开启，服务端的自我开启就是根据客户端的续约次数是否小于最小续约次数来进行判断的。

Eureka心跳的流程：

客戶端會啓動一個30秒一次的綫程發送心跳續約的請求。

服務端接收到心跳續約的請求后悔更新這個服務的續約時間，更新續約數量，這個續約數量和服務端是否開啓自我保護功能有關，續約時間和判斷服務是否過期有關。

    lastUpdateTimestamp = System.currentTimeMillis() + duration;

其實上面就已經完成了續約的工作，但是還要結合著過期判斷來看

服務端會開啓一個定時任務每60秒就判斷一下所有的服務是否過期，判斷的主要方法就是這個

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

duration ： 过期间隔，默认为90秒
evictionTimestamp ： 实例下线时间，当客户端下线时，会更新这个时间。
lastUpdateTimestamp ： 为最后更新时间 ， 这里有个错误，因为续约的时候，更新这个时间的时候，加上了duration ， 但是在最终做判断的时候
lastUpdateTimestamp + duration + additionalLeaseMs ， 这个地方还加了一遍，也就导致了，当前时间必须要大于实际最后更新时间180秒，才会认为他过期 （撇开additionalLeaseMs这个因素不谈）

DiscoverClient

com.netflix.discovery.DiscoveryClient ,使用的@Inject //google guice 注入遵循 JSR-330规范

@Inject
DiscoveryClient(ApplicationInfoManager applicationInfoManager, EurekaClientConfig config, AbstractDiscoveryClientOptionalArgs args,
                Provider<BackupRegistry> backupRegistryProvider) {
     
    // 省略N多代码
    // 初始化定时器信息
    initScheduledTasks();
    
}
private void initScheduledTasks() {
    // 省略N多代码。。。
    if (clientConfig.shouldRegisterWithEureka()) {
        int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
        int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
        logger.info("Starting heartbeat executor: " + "renew interval is: " + renewalIntervalInSecs);
 
        // 在这里，初始化一个定时器任务
        scheduler.schedule(
                new TimedSupervisorTask(
                        "heartbeat",
                        scheduler,
                        heartbeatExecutor,
                        renewalIntervalInSecs,
                        TimeUnit.SECONDS,
                        expBackOffBound,
                        new HeartbeatThread()
                ),
                renewalIntervalInSecs, TimeUnit.SECONDS);
 
        // 省略N多代码。。。
    } else {
        logger.info("Not registering with Eureka server per configuration");
    }
}

由上可以看出，在DiscoverClient这个类初始化的时候，会初始化定期任务，每30秒执行一次，用来发送心跳

HeartbeatThread

这个是用来续约的线程，主要看其run方法，

private class HeartbeatThread implements Runnable {
 
    public void run() {
        if (renew()) {
            // 更新最后一次心跳的时间
            lastSuccessfulHeartbeatTimestamp = System.currentTimeMillis();
        }
    }
}
// 续约的主方法
boolean renew() {
    EurekaHttpResponse<InstanceInfo> httpResponse;
    try {
        httpResponse = eurekaTransport.registrationClient.sendHeartBeat(instanceInfo.getAppName(), instanceInfo.getId(), instanceInfo, null);
        logger.debug("{} - Heartbeat status: {}", PREFIX + appPathIdentifier, httpResponse.getStatusCode());
        if (httpResponse.getStatusCode() == 404) {
            REREGISTER_COUNTER.increment();
            logger.info("{} - Re-registering apps/{}", PREFIX + appPathIdentifier, instanceInfo.getAppName());
            return register();
        }
        return httpResponse.getStatusCode() == 200;
    } catch (Throwable e) {
        logger.error("{} - was unable to send heartbeat!", PREFIX + appPathIdentifier, e);
        return false;
    }
}

上面的代码很简单，主要就是启动一个线程，然后线程执行renew()方法， 最终发送心跳给Eureka-Server

接口地址： apps/ + appName + /' + id ，

如果接口返回值为404，就是说不存在，从来没有注册过，那么重新走注册流程

lastDirtyTimestamp

即该instance在client端最后被修改的时间戳

Eureka-Server接收心跳

InstanceResource

@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);
    // 续约
    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 = null;
    // 比较lastDirtyTimestamp 
    if (lastDirtyTimestamp != null && serverConfig.shouldSyncWhenTimestampDiffers()) {
        // 比较lastDirtyTimestamp的大小，这个还是比较重要的
        response = this.validateDirtyTimestamp(Long.valueOf(lastDirtyTimestamp), isFromReplicaNode);
        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;
}
 
 
 
 
 
 
private Response validateDirtyTimestamp(Long lastDirtyTimestamp,
                                        boolean isReplication) {
    // 获取本机的instance实例信息
    InstanceInfo appInfo = registry.getInstanceByAppAndId(app.getName(), id, false);
    if (appInfo != null) {
        //如果lastDirtyTimestamp不为空，并且lastDirtyTimestamp和本地的不相等
        if ((lastDirtyTimestamp != null) && (!lastDirtyTimestamp.equals(appInfo.getLastDirtyTimestamp()))) {
            Object[] args = {id, appInfo.getLastDirtyTimestamp(), lastDirtyTimestamp, isReplication};
            // lastDirtyTimestamp>本地的时间，则认为当前实例是无效的，返回404错误，客户端重新发起注册
            if (lastDirtyTimestamp > appInfo.getLastDirtyTimestamp()) {
                logger.debug(
                        "Time to sync, since the last dirty timestamp differs -"
                                + " ReplicationInstance id : {},Registry : {} Incoming: {} Replication: {}",
                        args);
                return Response.status(Status.NOT_FOUND).build();
            } else if (appInfo.getLastDirtyTimestamp() > lastDirtyTimestamp) {
                // 如果是集群同步请求，本地的时间，大于客户端传过来的时间，则返回 “冲突” 这个状态回去，以本地的时间大的为准
                if (isReplication) {
                    logger.debug(
                            "Time to sync, since the last dirty timestamp differs -"
                                    + " ReplicationInstance id : {},Registry : {} Incoming: {} Replication: {}",
                            args);
                    return Response.status(Status.CONFLICT).entity(appInfo).build();
                } else {
                    return Response.ok().build();
                }
            }
        }
 
    }
    return Response.ok().build();
}

代码说明：

1.lastDirtyTimestamp 是客户端向服务端发请求的版本号 ， 一切请求都以版本号大的为准。， 如： 注册

2.在调用续约的方法之后，Eureka Server 会对请求过来的lastDirtyTimestamp和本地的做对比， 如果

请求lastDirtyTimestamp>本地的时间，则认为当前实例是无效的，返回404错误，客户端重新发起注册。为什么在“lastDirtyTimestamp>本地的时间，则认为当前实例是无效的”呢？lastDirtyTimestamp如果发生变动，说明这个实例被更改过，所以服务端的实例就不是最新的了

3.如果是集群同步请求，本地的时间，大于其他Eureka Server传过来的时间，则返回 “冲突” 这个状态回去，

以本地的时间大的为准，注意是集群同步请求，如果是客户端传过的，是不会有这个规则的。

应用续约

//PeerAwareInstanceRegistryImpl.java
public boolean renew(final String appName, final String id, final boolean isReplication) {
    // 执行续约操作
    if (super.renew(appName, id, isReplication)) {
        // 同步Eureka-Server集群
        replicateToPeers(Action.Heartbeat, appName, id, null, null, isReplication);
        return true;
    }
    return false;
}


//AbstractInstanceRegistry.java
public boolean renew(String appName, String id, boolean isReplication) {
    // 增加续约次数到统计枚举
    RENEW.increment(isReplication);
    // 从Eureka-Server端本地的CurrentHashMap中，通过appName获取Lease信息
    Map<String, Lease<InstanceInfo>> gMap = registry.get(appName);
    Lease<InstanceInfo> leaseToRenew = null;
    if (gMap != null) {
        leaseToRenew = gMap.get(id);
    }
    // lease为空，lease在第一次注册的时候会创建，为空，则表示从来没有注册过，租约不存在
    if (leaseToRenew == null) {
        RENEW_NOT_FOUND.increment(isReplication);
        logger.warn("DS: Registry: lease doesn't exist, registering resource: {} - {}", appName, id);
        return false;
    } else {
        // 获取lease里面的instance信息
        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)) {
                Object[] args = {
                        instanceInfo.getStatus().name(),
                        instanceInfo.getOverriddenStatus().name(),
                        instanceInfo.getId()
                };
                logger.info(
                        "The instance status {} is different from overridden instance status {} for instance {}. "
                                + "Hence setting the status to overridden status", args);
                instanceInfo.setStatus(overriddenInstanceStatus);
            }
        }
        // 设置每分钟的续约次数
        renewsLastMin.increment();
        // 续约
        leaseToRenew.renew();
        return true;
    }
}

从上面可以看到整个续约过程，主要就是从本地的CurrentHashMap中获取租约信息， 获取到了之后，设置每分钟的续约次数以及续约时间。
renewsLastMin.increment()， 这个里面。主要是更新一个currentBucket的变量，类型为AtomicLong ， 同时有个定时器一分钟去更新一次。一分钟之后，这个值会重新设置为0 。

leaseToRenew.renew() , 更新lastUpdateTimestamp, duration默认为90秒

//Lease.java
public void renew() {
    lastUpdateTimestamp = System.currentTimeMillis() + duration;
 
}

总结：

在一下三种情况，续约是返回404 ， 需要客户端重新发起注册的。

1.当客户端的lastDirtyTimestamp> 大于服务端的instance的lastDirtyTimestamp时候，会认为服务端

的信息是无效的，因此无法续约，需要重新发起注册请求。

2.服务端的注册信息不存在

3.服务端的instance的status = UNKONW， 为什么会出现UNKONW这个状态呢，因为在deleteStatusOverride

的时候存在传入UNKONW的可能性。

作者：sharedCode
链接：https://www.jianshu.com/p/b0397618c2f0
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。