Eureka源码深度刨析-(8)Eureka心跳续约与实例摘除机制

最新推荐文章于 2023-01-04 08:15:00 发布
最新推荐文章于 2023-01-04 08:15:00 发布
阅读量365 收藏
点赞数
分类专栏： Java源码深度解析-netflix 文章标签： 微服务架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Josh_scott/article/details/119243212
版权

“不积跬步，无以至千里。”

这篇文章来看看Eureka中两个重要的核心机制：心跳续约与实例摘除。

心跳续约

eureka client每隔一定时间，向server发送心跳，让eureka server知道自己还活着，还可以继续对外提供服务，简言之，就是如此。

这个心跳是通过一个调度线程池实现的，根据之前的经验，跟client有关的功能，找DiscoveryClient这个类，准没错，

把eureka源码读完之后，会发现，DiscoveryClient里面近2000行代码，几乎涵盖了client端的所以功能。

找个initScheduledTasks()，可以很明显的看到跟心跳机制有关的代码

// Heartbeat timer
heartbeatTask = new TimedSupervisorTask(
    "heartbeat",
    scheduler,
    heartbeatExecutor,
    renewalIntervalInSecs,
    TimeUnit.SECONDS,
    expBackOffBound,
    new HeartbeatThread()
);
scheduler.schedule(
    heartbeatTask,
    //public static final int DEFAULT_LEASE_RENEWAL_INTERVAL = 30;
    //这个renewalIntervalInSecs默认值是30
    renewalIntervalInSecs, TimeUnit.SECONDS);

通过一个HeartbeatThread线程类，放到一个调度线程池里，每隔30s执行一次HeartbeatThread线程的逻辑，发送心跳

private class HeartbeatThread implements Runnable {

    public void run() {
        if (renew()) {
            lastSuccessfulHeartbeatTimestamp = System.currentTimeMillis();
        }
    }
}

在renew()方法中，走的是EurekaHttpClient的sendHeartbeat()方法，

 /**
   * Renew with the eureka service by making the appropriate REST call
   */
boolean renew() {
    EurekaHttpResponse<InstanceInfo> httpResponse;
    try {
        //发送心跳
        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;
    }
}

完成请求参数的拼接，发送的url类似：http://localhost:8080/v2/apps/ServiceA/i-000000-1，走的是PUT请求

@Override
public EurekaHttpResponse<InstanceInfo> sendHeartBeat(String appName, String id, InstanceInfo info, InstanceStatus overriddenStatus) {
    String urlPath = "apps/" + appName + '/' + id;
    Response response = null;
    try {
        WebTarget webResource = jerseyClient.target(serviceUrl)
            .path(urlPath)
            .queryParam("status", info.getStatus().toString())
            .queryParam("lastDirtyTimestamp", info.getLastDirtyTimestamp().toString());
        if (overriddenStatus != null) {
            webResource = webResource.queryParam("overriddenstatus", overriddenStatus.name());
        }
        Builder requestBuilder = webResource.request();
        addExtraProperties(requestBuilder);
        addExtraHeaders(requestBuilder);
        requestBuilder.accept(MediaType.APPLICATION_JSON_TYPE);
        //.put(...) 可以发现心跳续约走的是put请求
        response = requestBuilder.put(Entity.entity("{}", MediaType.APPLICATION_JSON_TYPE)); // Jersey2 refuses to handle PUT with no body
        EurekaHttpResponseBuilder<InstanceInfo> eurekaResponseBuilder = anEurekaHttpResponse(response.getStatus(), InstanceInfo.class).headers(headersOf(response));
        if (response.hasEntity()) {
            eurekaResponseBuilder.entity(response.readEntity(InstanceInfo.class));
        }
        return eurekaResponseBuilder.build();
        ... ...
    }

服务端处理心跳的Resource是InstanceResource

根据路径匹配，找到renewLease()方法

@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;
    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;
}

发现server端处理心跳续约的是registry的renew(...)方法，服务注册相关的功能，使用服务注册表来处理也算正常

这个PeerAwareInstanceRegistry我提醒你注意，跟之前提过的DiscoveryClient类似，也是核心类，server端的很多核心机制，都在这个注册表的类里面，要善于抓住核心。

调用了父类的renew方法

public boolean renew(final String appName, final String id, final boolean isReplication) {
    if (super.renew(appName, id, isReplication)) {
        replicateToPeers(Action.Heartbeat, appName, id, null, null, isReplication);
        return true;
    }
    return false;
}

这个方法的核心逻辑是根据服务名称和实例Id，拿到一个Lease<InstanceInfo>，然后调用renew()方法

这么大一坨代码，有用的就下面那一行，leaseToRenew.renew();

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

            }
        }
        renewsLastMin.increment();
        leaseToRenew.renew();
        return true;
    }
}

调用renew()方法，更新了一下lastUpdateTimestamp这个变量的时间戳

总结一下，心跳续约就是更新了服务实例的上次更新的时间戳为当前时间戳

public void renew() {
    //这个duration是服务注册的补偿时间，默认是90s
    //public static final int DEFAULT_DURATION_IN_SECS = 90;
    lastUpdateTimestamp = System.currentTimeMillis() + duration;

}

服务注册时，lastUpdateTimestamp取的就是当前时间戳

registrant.setLastUpdatedTimestamp();

public void setLastUpdatedTimestamp() {
    this.lastUpdatedTimestamp = System.currentTimeMillis();
}

在一个分布式系统里面，心跳机制，是很重要的，可以让一个中枢控制的服务，监控所有其他的工作服务是否还活着，这个所以是一个心跳机制，就是每次更新心跳，就更新最近的一次时间戳就可以了。

eureka心跳机制

实例摘除

比如现在线上有一个注册中心，还有很多个服务，在线上跑着，各个服务都会每隔一段时间发送一次心跳，但如果某个服务现在要停机，或者是重启，首先就会关闭，此时需要你自己去调用eurekaClient的shutdown()，将服务实例停止，所以说呢，我们重点就是从eurekaClient的shutdown()方法开始入手来看。

比如说你如果eureka client也是跟着一个web容器来启动的，ContextListener，里面有一个contextDestroyed()，在这个方法里，你就调用eureka client的shutdown()方法就可以了。

来规矩，调用的是DisvoveryClient的shutdown()方法

/**
   * Shuts down Eureka Client. Also sends a deregistration request to the
   * eureka server.
   */
@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());
        }

        cancelScheduledTasks();

        // If APPINFO was registered
        if (applicationInfoManager != null
            && clientConfig.shouldRegisterWithEureka()
            && clientConfig.shouldUnregisterOnShutdown()) {
            applicationInfoManager.setInstanceStatus(InstanceStatus.DOWN);
            unregister();
        }

        if (eurekaTransport != null) {
            eurekaTransport.shutdown();
        }

        heartbeatStalenessMonitor.shutdown();
        registryStalenessMonitor.shutdown();

        Monitors.unregisterObject(this);

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

然后调用unregister()来取消服务实例的注册

调用EurekaHttpClient的cancel()方法，http://localhost:8080/v2/apps/ServiceA/i-00000-1，发送的是DELETE请求

void unregister() {
    // It can be null if shouldRegisterWithEureka == false
    if(eurekaTransport != null && eurekaTransport.registrationClient != null) {
        try {
            logger.info("Unregistering ...");
            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);
        }
    }
}

@Override
public EurekaHttpResponse<Void> cancel(String appName, String id) {
    String urlPath = "apps/" + appName + '/' + id;
    Response response = null;
    try {
        Builder resourceBuilder = jerseyClient.target(serviceUrl).path(urlPath).request();
        addExtraProperties(resourceBuilder);
        addExtraHeaders(resourceBuilder);
        //发送Delete请求
        response = resourceBuilder.delete();
        return anEurekaHttpResponse(response.getStatus()).headers(headersOf(response)).build();
    } finally {
        if (logger.isDebugEnabled()) {
            logger.debug("Jersey2 HTTP DELETE {}/{}; statusCode={}", serviceUrl, urlPath, response == null ? "N/A" : response.getStatus());
        }
        if (response != null) {
            response.close();
        }
    }
}

根据路径匹配规则，最终会调用server端，由InstanceResource组件的cancelLease()方法来处理服务下线的请求

@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();
    }

}

走到registry的cancel方法中

先在本地cancel清理掉这个注册的服务实例，然后调用replicateToPeers方法同步给集群其他的节点，通知它们把该服务实例进行清理

@Override
public boolean cancel(final String appName, final String id,
                      final boolean isReplication) {
    if (super.cancel(appName, id, isReplication)) {
        replicateToPeers(Action.Cancel, appName, id, null, null, isReplication);

        return true;
    }
    return false;
}

服务下线的逻辑比较简单，

（1）就是将服务实例从eureka server的map结构的注册表中移除掉，gMap.remove(id)

（2）把这个被移除的服务放入了一个recentCanceledQueue队列中，看字面意思就是最近被移除这么个队列

（3）调用leaseToCancel.cancel()，设置evictionTimestamp驱逐时间为当前时间戳

（4）把这个被移除的实例放入recentlyChangedQueue最新变动队列中，那么下次客户端增量拉取的时候就可以拉取到，然后在本地进行清理，就不会调用到这个下线的实例上面去了

（5）最后调用invalidateCache()方法过期RW缓存中的数据，因为这个实例已经被清理了

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) {
            //清理服务实例，从Map数据结构中移除
            leaseToCancel = gMap.remove(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 {
            leaseToCancel.cancel();
            InstanceInfo instanceInfo = leaseToCancel.getHolder();
            String vip = null;
            String svip = null;
            if (instanceInfo != null) {
                instanceInfo.setActionType(ActionType.DELETED);
                recentlyChangedQueue.add(new RecentlyChangedItem(leaseToCancel));
                instanceInfo.setLastUpdatedTimestamp();
                vip = instanceInfo.getVIPAddress();
                svip = instanceInfo.getSecureVipAddress();
            }
            invalidateCache(appName, vip, svip);
            logger.info("Cancelled instance {}/{} (replication={})", appName, id, isReplication);
        }
    } finally {
        read.unlock();
    }

    synchronized (lock) {
        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;
}

/**
 * Cancels the lease by updating the eviction time.
 */
public void cancel() {
    if (evictionTimestamp <= 0) {
        evictionTimestamp = System.currentTimeMillis();
    }
}

过期RW缓存的代码单独贴出来，最终会把这个服务对应的缓存数据清理，不过看代码应该是把这个RW缓存整个清空了，感兴趣的话可以打个断点看看

@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),
                new Key(Key.EntityType.Application, ALL_APPS, type, v, EurekaAccept.full),
                new Key(Key.EntityType.Application, ALL_APPS, type, v, EurekaAccept.compact),
                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.invalidate(key);

下次eureka client来增量拉取服务注册表的时候，会发现readOnlyCacheMap里没有，会找readWriteCacheMap也会发现没有，然后就会从注册表里抓取增量注册表，此时就会将上面那个recentlyChangedQueue中的记录返回。

其实在eureka server将本地服务下线之后，也会向集群中其他的server节点去同步服务下线的这么一个事情，通知其他节点将此服务下线，那么下次client来拉取注册表的时候，无论从哪个server去拉取最新的注册表，都没有了这个已经下线的服务实例，保证了集群数据的一致性；
这块代码最终会调用到HttpReplicationClient.cancel()方法去通知集群其他节点执行操作，感兴趣的可以去跟一下，这里就不赘述了。

@Override
public boolean cancel(final String appName, final String id,
                       final boolean isReplication) {
     if (super.cancel(appName, id, isReplication)) {
         //同步服务实例下线通知到集群其他节点上面
         replicateToPeers(Action.Cancel, appName, id, null, null, isReplication);

         return true;
     }
     return false;
 }
知秋丶
关注
专栏目录
[享学Eureka] 一、源生Eureka介绍 --- 基于注册中心的服务发现
架构师：通透，才能写出好代码！
03-23 2573
本系列文章学习源生Eureka，以及它在`Spring Cloud`技术体系中的应用和原理剖析。本文开始研究Spring Cloud体系中的注册中心：当前最流行的`Eureka`。`Eureka`作为服务注册中心对**整个微服务架构**起着**最核心**的整合作用，因此我个人认为对Eureka还是有很大的必要进行深入研究。
Eureka Client与Eureka Server之间的心跳机制
王二小的博客
01-23 1560
1.心跳是从什么时候开始的 在每一个EurekaClient启动的时候，都会有一个HeartbeatThread的心跳线程，这个就是一个后跳线程，保证默认30秒的时候向EurekaServer发送一个信息的请求，告诉EurekaServer当前的EurekaClient还存活着。eureka.instance.lease-renewal-interval-in-seconds，这个参数可以来配置对应的心跳间隔时间。 2.EurekaServer端接收到心跳做了什么操作 EurekaServ...
spring cloud：eureka源码之我见（八）服务实例故障自动感知与服务实例自动摘除机制
weixin_41703510的博客
07-23 337
很多时候，服务实例并不是主动放delete请求下线的，而是宕机或者其他情况，并不会去通知注册中心（eureka server）。 eureka server是靠着心跳（续约）实现服务实例故障的自动感知以及服务实例自动摘除机制。 eureka server在EurekaBootStrap中启动初始化的时候，执行了一行代码registry.openForTraffic(applicationInfoManager, registryCount); 这个方法的最后一行，调用了父类的postInit()方法
eureka-server端的服务续约（心跳检测）
weixin_42163781的博客
11-12 595
今天主要记录服务端心跳续约原理！！！ 刚开始学的时候还是有很多疑惑的，下面将我的疑惑记录在这里！！ 问题1：服务续约他所做的到底是什么事情？ 当客户端注册服务完成后，他会通过定时任务（默认30秒）定时向服务端发送Rest请求，告知服务端自身的状态，避免被服务剔除，说白了，就是检测当前客户端是否可用。 问题2：服务端接受到客户端的服务续约请求后，他怎么进行的服务续约，也就是说，我收到了你的请求，那么服务续约究竟是通过一个状态值来记录的，还是通过其他存储来记录的呢？？？ Eureka的服务续约功能是在eure
五.SpringCloud源码剖析-Eureka Client服务续约
墨家巨子@俏如来
08-31 573
什么是服务续约 EureakClient会定时向EureakServer发送续约心跳(默认30s/次) ，来告诉EurekaServer自己的健康状况，默认情况下3次续约失败(90s)，EurekaServer考虑剔除续约失败的客户端服务 初始化定时任务 在EuerakClient中依然是通过scheduler定时实现，在com.netflix.discovery.DiscoveryClient#initScheduledTasks中进行初始化,源码如下 /** * Initializes all
微服务基础----Eureka配置心跳和剔除不可用服务
qq_43154385的博客
04-23 1959
1、注意 改配置建议在开发和测试环境下使用，尽量不要在生产环境使用。 2、背景 由于Eureka拥有自我保护机制，当其注册表里服务因为网络或其他原因出现故障而关停时，Eureka不会剔除服务注册，而是等待其修复。这是AP的一种实现。 3、解决方案 Eureka server配置文件： eureka: server: enable-self-preserva...
springcloud-eureka的自我保护机制关闭
nice、小兴的博客
04-09 225
关闭eureka的自我保护机制 Eureka Server 在运行期间会去统计心跳失败比例在 15 分钟之内是否低于 85%，如果低于 85%，Eureka Server 会将这些实例保护起来，让这些实例不会过期，但是在保护期内如果服务刚好这个服务提供者非正常下线了，此时服务消费者就会拿到一个无效的服务实例，此时会调用失败，对于这个问题需要服务消费者端要有一些容错机制，如重试，断路器（hystri...
springcloud 之 eureka 源码解析(2)-Eureka Server 启动流程分析
yeyinzhu3211的专栏
12-29 653
springcloud 之 eureka 源码解析(2)-Eureka Server 启动流程分析
SpringCloud Netflix复习之Eureka
最新发布
bazhuayu_1203的博客
01-04 589
Eureka核心功能和源码验证
SpringCloud Eureka管理机制
weixin_45389262的博客
03-21 204
心跳检测 Eureka Client会定期（默认30秒）向Eureka Server端发送信息刷新注册信息，表示续约。若在指定时间(默认90秒)没有向服务器发送信息，则服务端将其从服务列表中删除。 控制发送心跳间隔 eureka.instance.lease-renewal-interval-in-seconds 表示eureka client发送心跳给server端的频率，默认30秒。 如果...
8、Eureka 源码解析 之 Eureka Client 服务下线
carl.zhao的专栏
01-06 629
下面是官方提供的 Eureka 架构图： 1、Eureka Client 服务下线 当 Eureka Client 服务关闭之前会调用 DiscoveryClient#shutdown 方法。因为这个方法上面标注了 @PreDestroy 在对象销毁之前这个方法就会被调用。 @PreDestroy @Override public synchronized void shutdown() { if (isShutdown.compareAndSet(false,
Eureka源码解析(三)—服务续约(心跳)
李秋阳的博客
06-24 6655
Eureka服务续约(心跳)EurekaClient在注册到EurekaServer端之后，会通过启动时初始化的定时任务定时向EurekaServer端进行服务续约(心跳)。本篇文章主要解析EurekaClient端向EurekaServer端发起服务续约(心跳)请求以及EurekaServer端接收请求后的具体操作，分为EurekaClient端发送请求和EurekaServer端接收请求来解析...
深入理解Eureka
weixin_34198797的博客
06-11 1005
转载请标明出处：blog.csdn.net/forezp/arti…本文出自方志朋的博客 Eureka的一些概念 Register：服务注册当Eureka客户端向Eureka Server注册时，它提供自身的元数据，比如IP地址、端口，运行状况指示符URL，主页等。 Renew：服务续约Eureka客户会每隔30秒发送一次心跳来续约。 通过续约来告知Eureka Server该Eureka...
Eureka心跳机制与自动保护机制原理分析
m0_51660523的博客
10-18 4065
Eureka心跳机制: 在应用启动后，节点们将会向EurekaServer发送心跳,默认周期为30秒，如果EurekaServer在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除(默认90秒)。 Eureka自动保护机制： EurekaServer在运行期间会去统计心跳成功的比例在15分钟之内是否低于85%,如果低于85%，EurekaServer会认为当前实例的客户端与自己的心跳连接出现了网络故障，那么EurekaServe...
简单了解一下Eureka自我保护和心跳
关启培的博客
02-28 1095
Eureka的自我保护： 一句话：某时刻某一个微服务不可用了，Eureka不会立即清理，依旧会对微服务的信息进行保护。 导致原因： 对于心跳的问题： 启动两个Eureka Client，过了一会，停了其中一个，访问注册中心时，界面上显示了红色粗体警告信息： EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCE...
SpringCloud系列——EurekaClient注册表更新机制
罗小辉的专栏
09-07 1145
Eureka注册表整体框架图： Eureka客户端更新机制图解 还是直接看图来得实在： 这个注册表中含有所有服务的信息，比如服务的IP，端口，实例状态等，在这个商城项目中，用户在浏览商品之后，想买此商品，这时商品服务会去调用订单服务，而获取订单服务的IP和端口就是由Eureka注册中心中的注册表维护着的。 DiscoveryClient类解析 DiscoveryClient是Eureka客户端向Erueka服务端获取注册表/注册/发送心跳的具体实现类，可以说是我们跟Eureka客户端打交道最多的一个类了。
Eureka的服务剔除与保护机制
xinyi_java的博客
08-16 1928
1.服务剔除 注册到eureka的服务可能由于内存溢出或网络故障等原因使得服务不能正常的工作，而服务注册中心并未收到“服务下线”的请求。服务注册中心在启动时会创建一个定时任务，默认每隔一段时间（默认为60秒）将当前清单中超时（默认为90秒）没有续约的服务剔除，这个操作被称为失效剔除。 2.服务保护 我们关停一个服务，很可能会在Eureka面板看到一条警告： 这是触发了Eureka的自我保护机制。当服务未按时进行心跳续约时，Eureka会统计服务实例最近15分钟心跳续约的比例是否低于了85%。
Eureka的注册表拉取及多级缓存机制简析
LO_YUN的博客
07-16 2193
只读缓存 + 读写缓存
Eureka核心源码解析
yygr的博客
05-26 1164
https://blog.csdn.net/trunks2009/article/details/106425297?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_title~default-0-106425297-blog-110039533.pc_relevant_paycolumn_v3&spm=1001.2101.3001.4242.1&utm_relevant_index=3 Eureka
Eureka源码解析：服务注册、续约与剔除机制详解
深入理解Eureka之源码解析是一篇关于Eureka分布式服务发现框架的详尽分析文章。Eureka是Netflix开发的一款用于管理微服务注册与发现的核心组件，它在分布式系统中扮演着至关重要的角色，确保服务之间的连接和负载...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值