Eureka 心跳和服务续约源码探秘——图解、源码级解析

这篇具有很好参考价值的文章主要介绍了Eureka 心跳和服务续约源码探秘——图解、源码级解析。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

🍊 Java学习:社区快速通道

🍊 深入浅出RocketMQ设计思想:深入浅出RocketMQ设计思想

🍊 绝对不一样的职场干货:大厂最佳实践经验指南


📆 最近更新:2023年5月25日


🍊 点赞 👍 收藏 ⭐留言 📝 都是我最大的动力!


分布式系统的心跳机制

分布式系统是由多个计算机节点构成的系统,这些节点之间通过网络进行通信和协作。由于节点之间的网络连接不可靠,因此在分布式系统中,一个节点可能会因为网络故障或其他原因而失去与其他节点的联系。为了解决这个问题,分布式系统引入了心跳机制。

Eureka 心跳和服务续约源码探秘——图解、源码级解析

心跳机制是指每个节点定期向其他节点发送“心跳”消息,以表明自己的存在和正常运行。如果一个节点在一段时间内没有收到来自其他节点的心跳消息,那么它就会认为这些节点已经失去了联系,并采取相应的措施,例如重新选举领导节点或者启动备份节点。


心跳机制的实现方式

心跳机制的实现方式可以分为基于UDP协议、基于TCP协议和基于HTTP协议三种。

  • 基于UDP协议的心跳机制具有实现简单、网络开销小等优点。但由于UDP协议本身不可靠,因此可能会出现一些误判情况。

  • 基于TCP协议的心跳机制具有可靠性高、误判率低等优点。但由于TCP协议本身的特性,可能会出现一些网络延迟等问题。

  • 基于HTTP协议的心跳机制具有易于实现、可扩展性好等优点。但由于HTTP协议本身的特性,可能会出现一些网络延迟等问题。


在实际应用中,需要根据具体情况选择合适的心跳机制实现方式。

对于实时性要求较高的应用场景,可以选择基于UDP协议的心跳机制;对于对可靠性要求较高的应用场景,可以选择基于TCP协议的心跳机制。


SpringCloud中的心跳

SpringCloud也借助“心跳”来知晓服务的可用性,心跳检测有以下四种特点:

  1. 客户端发起: 心跳服务是由每个服务节点根据配置的时间主动发起的。
  2. 同步状态: 要告诉注册中心自己的状态,快不行了(OUT_OF_SERVICE)或是一切正常(UP)。
  3. 服务剔除: 对一段时间无响应的服务,要主动将其从注册列表中剔除,以防服务调用方请求失败。
  4. 服务续约: 服务续约底层也是靠着心跳来实现的,其中包含了一套处理流程。

关于服务续约的一些细节

服务续约分为两步:

  1. 将服务节点的状态同步到注册中心,这一步需要借助客户端的心跳功能来主动发送。
  2. 当心跳包到达注册中心的时候,注册中心有一套判别机制,来判定当前的续约心跳是否合理。并根据判断结果修改当前instance在注册中心记录的同步时间。

服务节点向注册中心发送续约请求:

  1. 服务续约请求: 客户端有一个DiscoverClient类,它是所有操作的入口。所以续约服务就从这个类的renew方法开始
  2. 发送心跳: 服务续约借助心跳来实现,因此发给注册中心的两个重要参数分别是服务的状态(UP)和lastDirtyTimeStamp
  • 如果续约成功,注册中心则会返回200的HTTP code
  • 如果续约不成功,注册中心返回404,这里的404并不是说没有找到注册中心的地址,而是注册中心认为当前服务节点并不存在。这个时候再怎么续约也不行了,客户端需要触发一次重新注册操作。
  1. 在重新注册之前,客户端会做下面两个操作,然后再主动调用服务注册流程:
  • 设置lastDirtyTimeStamp :由于重新注册意味着服务节点和注册中心的信息不同步,因此需要将当前系统时间更新到lastDirtyTimeStamp
  • 标记为脏节点
  1. 当注册成功的时候,清除脏节点标记,但是lastDirtyTimeStamp不会清除,因为这个属性将会在后面的服务续约中作为参数发给注册中心,以便服务中心判断节点的同步状态。

Eureka 心跳和服务续约源码

通过本章节,可以了解到:

  • 客户端心跳发送内容是什么?
  • 客户端续约流程
  • 服务端租约更新流程

在真正阅读之前,不妨先尝试回答一下上面的3个问题,带着疑问看文章,收获会更大 ~ 下面开始进入正题


客户端源码

打开DiscoveryClient,入口便是构造函数:

Eureka 心跳和服务续约源码探秘——图解、源码级解析
这里只关注服务的心跳是怎么发送的
Eureka 心跳和服务续约源码探秘——图解、源码级解析
通过方法名就可以看出这是一个在后台定时触发的任务

private void initScheduledTasks() {
    int renewalIntervalInSecs;
    int expBackOffBound;
    if (this.clientConfig.shouldFetchRegistry()) {
        renewalIntervalInSecs = this.clientConfig.getRegistryFetchIntervalSeconds();
        expBackOffBound = this.clientConfig.getCacheRefreshExecutorExponentialBackOffBound();
        this.scheduler.schedule(new TimedSupervisorTask("cacheRefresh", this.scheduler, this.cacheRefreshExecutor, renewalIntervalInSecs, TimeUnit.SECONDS, expBackOffBound, new DiscoveryClient.CacheRefreshThread()), (long)renewalIntervalInSecs, TimeUnit.SECONDS);
    }
	
	// 从这里开始看
    if (this.clientConfig.shouldRegisterWithEureka()) {
        renewalIntervalInSecs = this.instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
        expBackOffBound = this.clientConfig.getHeartbeatExecutorExponentialBackOffBound();
        logger.info("Starting heartbeat executor: renew interval is: {}", renewalIntervalInSecs);
        this.scheduler.schedule(new TimedSupervisorTask("heartbeat", this.scheduler, this.heartbeatExecutor, renewalIntervalInSecs, TimeUnit.SECONDS, expBackOffBound, new DiscoveryClient.HeartbeatThread()), (long)renewalIntervalInSecs, TimeUnit.SECONDS);
        this.instanceInfoReplicator = new InstanceInfoReplicator(this, this.instanceInfo, this.clientConfig.getInstanceInfoReplicationIntervalSeconds(), 2);
        this.statusChangeListener = new StatusChangeListener() {
            public String getId() {
                return "statusChangeListener";
            }

            public void notify(StatusChangeEvent statusChangeEvent) {
                if (InstanceStatus.DOWN != statusChangeEvent.getStatus() && InstanceStatus.DOWN != statusChangeEvent.getPreviousStatus()) {
                    DiscoveryClient.logger.info("Saw local status change event {}", statusChangeEvent);
                } else {
                    DiscoveryClient.logger.warn("Saw local status change event {}", statusChangeEvent);
                }

                DiscoveryClient.this.instanceInfoReplicator.onDemandUpdate();
            }
        };
        if (this.clientConfig.shouldOnDemandUpdateStatusChange()) {
            this.applicationInfoManager.registerStatusChangeListener(this.statusChangeListener);
        }

        this.instanceInfoReplicator.start(this.clientConfig.getInitialInstanceInfoReplicationIntervalSeconds());
    } else {
        logger.info("Not registering with Eureka server per configuration");
    }
}

可以直接从上面的第10行开始关注

this.scheduler.schedule(
    new TimedSupervisorTask(
        "heartbeat", 
        this.scheduler, 
        this.heartbeatExecutor, 
        renewalIntervalInSecs, 
        TimeUnit.SECONDS, 
        expBackOffBound, 
        new DiscoveryClient.HeartbeatThread()
    ), 
    (long)renewalIntervalInSecs, TimeUnit.SECONDS);

是定时启动后台任务的方法

  • renewalIntervalInSecs表示每多少秒启动一次定时任务
  • expBackOffBound是用来计算最大delay时间的

this.maxDelay = this.timeoutMillis * (long)expBackOffBound;

new DiscoveryClient.HeartbeatThread()是发送心跳的具体逻辑

private class HeartbeatThread implements Runnable {
    private HeartbeatThread() {
    }

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

其中renew相当于续约的逻辑,心跳和续约是一套相互作用的机制,renew在客户端是发送了一个心跳,服务端接收了心跳之后会进行服务的续约

boolean renew() {
    try {
        EurekaHttpResponse<InstanceInfo> httpResponse = this.eurekaTransport.registrationClient.sendHeartBeat(this.instanceInfo.getAppName(), this.instanceInfo.getId(), this.instanceInfo, (InstanceStatus)null);
        logger.debug("DiscoveryClient_{} - Heartbeat status: {}", this.appPathIdentifier, httpResponse.getStatusCode());
        if (httpResponse.getStatusCode() == Status.NOT_FOUND.getStatusCode()) {
            this.REREGISTER_COUNTER.increment();
            logger.info("DiscoveryClient_{} - Re-registering apps/{}", this.appPathIdentifier, this.instanceInfo.getAppName());
            long timestamp = this.instanceInfo.setIsDirtyWithTime();
            boolean success = this.register();
            if (success) {
                this.instanceInfo.unsetIsDirty(timestamp);
            }

            return success;
        } else {
            return httpResponse.getStatusCode() == Status.OK.getStatusCode();
        }
    } catch (Throwable var5) {
        logger.error("DiscoveryClient_{} - was unable to send heartbeat!", this.appPathIdentifier, var5);
        return false;
    }
}

心跳包的发送逻辑

EurekaHttpResponse<InstanceInfo> httpResponse = this.eurekaTransport.registrationClient.sendHeartBeat(this.instanceInfo.getAppName(), this.instanceInfo.getId(), this.instanceInfo, (InstanceStatus)null);

和前面的服务注册一样一层层嵌套,第一层嵌套先是SessionEurekaClient
Eureka 心跳和服务续约源码探秘——图解、源码级解析
下一层是retry,再下一层是redirective,再下一层是matrix…和服务注册一模一样


直接进到最后一层AbstractJerseyEurekaHttpClient

public EurekaHttpResponse<InstanceInfo> sendHeartBeat(String appName, String id, InstanceInfo info, InstanceStatus overriddenStatus) {
    String urlPath = "apps/" + appName + '/' + id;
    ClientResponse response = null;

    EurekaHttpResponse var10;
    try {
        WebResource webResource = this.jerseyClient.resource(this.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.getRequestBuilder();
        this.addExtraHeaders(requestBuilder);
        response = (ClientResponse)requestBuilder.put(ClientResponse.class);
        EurekaHttpResponseBuilder<InstanceInfo> eurekaResponseBuilder = EurekaHttpResponse.anEurekaHttpResponse(response.getStatus(), InstanceInfo.class).headers(headersOf(response));
        if (response.hasEntity()) {
            eurekaResponseBuilder.entity(response.getEntity(InstanceInfo.class));
        }

        var10 = eurekaResponseBuilder.build();
    } finally {
        if (logger.isDebugEnabled()) {
            logger.debug("Jersey HTTP PUT {}/{}; statusCode={}", new Object[]{this.serviceUrl, urlPath, response == null ? "N/A" : response.getStatus()});
        }

        if (response != null) {
            response.close();
        }

    }

    return var10;
}

构造服务请求路径

Eureka 心跳和服务续约源码探秘——图解、源码级解析
之后构造WebResource对象

WebResource webResource = this.jerseyClient.resource(this.serviceUrl)
        .path(urlPath)
        .queryParam("status", info.getStatus().toString())
        .queryParam("lastDirtyTimestamp", info.getLastDirtyTimestamp()
        .toString());

这里的serviceUrl是注册中心的url,前面的是当前机器的url,“lastDirtyTimestamp”是一个核心的属性

之后就是组装参数的流程,最后将请求发送出去,至此客户端发送心跳的逻辑就结束了。


服务端流程

服务端使用InstanceResource中的renewLease方法来接收心跳包:

public Response renewLease(@HeaderParam("x-netflix-discovery-replication") String isReplication, @QueryParam("overriddenstatus") String overriddenStatus, @QueryParam("status") String status, @QueryParam("lastDirtyTimestamp") String lastDirtyTimestamp) {
    boolean isFromReplicaNode = "true".equals(isReplication);
    boolean isSuccess = this.registry.renew(this.app.getName(), this.id, isFromReplicaNode);
    if (!isSuccess) {
        logger.warn("Not Found (Renew): {} - {}", this.app.getName(), this.id);
        return Response.status(Status.NOT_FOUND).build();
    } else {
        Response response;
        if (lastDirtyTimestamp != null && this.serverConfig.shouldSyncWhenTimestampDiffers()) {
            response = this.validateDirtyTimestamp(Long.valueOf(lastDirtyTimestamp), isFromReplicaNode);
            if (response.getStatus() == Status.NOT_FOUND.getStatusCode() && overriddenStatus != null && !InstanceStatus.UNKNOWN.name().equals(overriddenStatus) && isFromReplicaNode) {
                this.registry.storeOverriddenStatusIfRequired(this.app.getAppName(), this.id, InstanceStatus.valueOf(overriddenStatus));
            }
        } else {
            response = Response.ok().build();
        }

        logger.debug("Found (Renew): {} - {}; reply status={}", new Object[]{this.app.getName(), this.id, response.getStatus()});
        return response;
    }
}

当前心跳包是来自服务的提供者,并不是冗余备份,所以isFromReplicaNode是false。下面代码

boolean isSuccess = this.registry.renew(this.app.getName(), this.id, isFromReplicaNode);

是续约的方法

public boolean renew(final String appName, final String serverId, boolean isReplication) {
    this.log("renew " + appName + " serverId " + serverId + ", isReplication {}" + isReplication);
    List<Application> applications = this.getSortedApplications();
    Iterator var5 = applications.iterator();

    while(var5.hasNext()) {
        Application input = (Application)var5.next();
        if (input.getName().equals(appName)) {
            InstanceInfo instance = null;
            Iterator var8 = input.getInstances().iterator();

            while(var8.hasNext()) {
                InstanceInfo info = (InstanceInfo)var8.next();
                if (info.getId().equals(serverId)) {
                    instance = info;
                    break;
                }
            }

            this.publishEvent(new EurekaInstanceRenewedEvent(this, appName, serverId, instance, isReplication));
            break;
        }
    }
    return super.renew(appName, serverId, isReplication);
}

方法的入参serverId一定是唯一的


其中

List<Application> applications = this.getSortedApplications();

获取所有的application,判断哪一个服务需要续约的时候是通过遍历的方式,当list里的ApplicationName和传入的name相同时再把appication下的所有instance全部拿到,找出instanceidserverId相同的就知道该为哪一个instance进行续约了


this.publishEvent(new EurekaInstanceRenewedEvent(this, appName, serverId, instance, isReplication));

发布一个续约成功的event


最后进入到return后面调用的renew函数里

public boolean renew(String appName, String id, boolean isReplication) {
    if (super.renew(appName, id, isReplication)) {
        this.replicateToPeers(PeerAwareInstanceRegistryImpl.Action.Heartbeat, appName, id, (InstanceInfo)null, (InstanceStatus)null, isReplication);
        return true;
    } else {
        return false;
    }
}

replicateToPeers表示高可用注册中心有多个中心节点,需要向peer同步,继续进到父类的renew方法:

public boolean renew(String appName, String id, boolean isReplication) {
    EurekaMonitors.RENEW.increment(isReplication);
    Map<String, Lease<InstanceInfo>> gMap = (Map)this.registry.get(appName);
    Lease<InstanceInfo> leaseToRenew = null;
    if (gMap != null) {
        leaseToRenew = (Lease)gMap.get(id);
    }

    if (leaseToRenew == null) {
        EurekaMonitors.RENEW_NOT_FOUND.increment(isReplication);
        logger.warn("DS: Registry: lease doesn't exist, registering resource: {} - {}", appName, id);
        return false;
    } else {
        InstanceInfo instanceInfo = (InstanceInfo)leaseToRenew.getHolder();
        if (instanceInfo != null) {
            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());
                EurekaMonitors.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", new Object[]{instanceInfo.getStatus().name(), instanceInfo.getOverriddenStatus().name(), instanceInfo.getId()});
                instanceInfo.setStatusWithoutDirty(overriddenInstanceStatus);
            }
        }

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

Map<String, Lease<InstanceInfo>> gMap = (Map)this.registry.get(appName);

通过appName得到所有的租约,因为现在只有一个节点,所以租约只是1,如果租约不为空则通过serverId拿到租约

leaseToRenew = (Lease)gMap.get(id);

租约不为空,先获得到instance的信息:

InstanceInfo instanceInfo = (InstanceInfo)leaseToRenew.getHolder();
  • 如果instance的状态是UNKNOWN,则EurekaMonitors.RENEW_NOT_FOUND增加isReplication
  • 如果instance和当前的instance不相同(之前是down,现在发来心跳包是up),需要执行
instanceInfo.setStatusWithoutDirty(overriddenInstanceStatus);
public synchronized void setStatusWithoutDirty(InstanceInfo.InstanceStatus status) {
    if (this.status != status) {
        this.status = status;
    }
}

这里是将status设置到instanceInfo里。


下面的方法是记录过去一分钟有多少租约被更新了:
this.renewsLastMin.increment();

更新租约:
leaseToRenew.renew();
public void renew() {
    this.lastUpdateTimestamp = System.currentTimeMillis() + this.duration;
}

这里仅仅是将lastUpdateTimestamp进行更新


回到InstanceResourcerenewLease方法里:
此时如果renew的逻辑不成功,那么返回给客户端NOT_FOUNDrenew成功则继续流程

Response response;
if (lastDirtyTimestamp != null && this.serverConfig.shouldSyncWhenTimestampDiffers()) {
    response = this.validateDirtyTimestamp(Long.valueOf(lastDirtyTimestamp), isFromReplicaNode);
    if (response.getStatus() == Status.NOT_FOUND.getStatusCode() && overriddenStatus != null && !InstanceStatus.UNKNOWN.name().equals(overriddenStatus) && isFromReplicaNode) {
        this.registry.storeOverriddenStatusIfRequired(this.app.getAppName(), this.id, InstanceStatus.valueOf(overriddenStatus));
    }
} else {
    response = Response.ok().build();
}

logger.debug("Found (Renew): {} - {}; reply status={}", new Object[]{this.app.getName(), this.id, response.getStatus()});
return response;

lastDirtyTimestamp表示最近一次和服务端出现脏数据的时间戳,是从客户端发来的


如果lastDirtyTimestamp不为空且设置了需要做数据同步,则进入if逻辑,先验证一下

response = this.validateDirtyTimestamp(Long.valueOf(lastDirtyTimestamp), isFromReplicaNode);
private Response validateDirtyTimestamp(Long lastDirtyTimestamp, boolean isReplication) {
    InstanceInfo appInfo = this.registry.getInstanceByAppAndId(this.app.getName(), this.id, false);
    if (appInfo != null && lastDirtyTimestamp != null && !lastDirtyTimestamp.equals(appInfo.getLastDirtyTimestamp())) {
        Object[] args = new Object[]{this.id, appInfo.getLastDirtyTimestamp(), lastDirtyTimestamp, isReplication};
        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();
        }

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

            return Response.ok().build();
        }
    }

    return Response.ok().build();
}

先根据appNameserverId获取InstanceInfo,如果产生了一段时间不同步的情况

  • 客户端发来的脏数据时间晚于服务端保存的脏数据时间,则客户端发生了事情没告诉服务端,返回NOT_FOUND
  • 服务端保存的脏数据时间比客户端发来的脏数据时间更新,则说明服务端保存的是新数据,如果是其他注册中心同步过来的则会返回CONFLICT;如果是客户端发过来的则直接返回OK

回到InstanceResourcerenewLease方法里:

if (response.getStatus() == Status.NOT_FOUND.getStatusCode() && overriddenStatus != null && !InstanceStatus.UNKNOWN.name().equals(overriddenStatus) && isFromReplicaNode) {
    this.registry.storeOverriddenStatusIfRequired(this.app.getAppName(), this.id, InstanceStatus.valueOf(overriddenStatus));
}

这个if进不去,此后服务续约的流程就完成了文章来源地址https://www.toymoban.com/news/detail-460674.html

到了这里,关于Eureka 心跳和服务续约源码探秘——图解、源码级解析的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Eureka中的心跳机制

    前言         从以前的单体架构到现在的微服务分布式架构, 随着架构的演变, 所需要的技术越来越多, 要求的也越来越多了, 今天来谈一下微服务领域中的心跳机制         在微服务领域,心跳机制很常见了, 比如Eureka. Nacos中的客户端和服务端的服务续约, Redis的主从复

    2024年02月16日
    浏览(29)
  • 深入源码解析ArrayList:探秘Java动态数组的机制与性能

    1.1 介绍ArrayList的基本概念和作用 在Java中,ArrayList是一个实现了List接口的动态数组。它可以根据需要自动增加大小,因此可以存储任意数量的元素。 基本概念: ArrayList是Java中常用的集合类之一,它可以存储对象,并且可以根据索引访问和操作这些对象。 ArrayList是基于数组

    2024年02月04日
    浏览(39)
  • SpringClound Eureka 1.9.12 版本源码解析

    Eureka启动,原生启动与SpringCloudEureka启动异同 我们先看看作为原生的EurekaServer启动的过程,作为一个Servlet应用,他的启动入口就是他的主要ServletContextListener类(这里是EurekaBootStrap)的contextInitialized方法 EurekaServerBootstrap @Override public void contextInitialized(ServletContextEvent event) { t

    2024年04月12日
    浏览(25)
  • RocketMQ 容错策略 解析——图解、源码级解析

    🍊 Java学习:Java从入门到精通总结 🍊 深入浅出RocketMQ设计思想:深入浅出RocketMQ设计思想 🍊 绝对不一样的职场干货:大厂最佳实践经验指南 📆 最近更新:2022年8月12日 🍊 个人简介:通信工程本硕💪、Java程序员🌕。做过科研paper,发过专利,优秀的程序员不应该只是C

    2023年04月08日
    浏览(30)
  • RocketMQ 存储优化技术 解析——图解、源码级解析

    🍊 Java学习:Java从入门到精通总结 🍊 深入浅出RocketMQ设计思想:深入浅出RocketMQ设计思想 🍊 绝对不一样的职场干货:大厂最佳实践经验指南 📆 最近更新:2023年1月13日 🍊 个人简介:通信工程本硕 for NJU💪、Java程序员🌕。做过科研paper,发过专利,优秀的程序员不应该只

    2024年02月19日
    浏览(37)
  • RocketMQ 消费者Rebalance 解析——图解、源码级解析

    🍊 Java学习:Java从入门到精通总结 🍊 深入浅出RocketMQ设计思想:深入浅出RocketMQ设计思想 🍊 绝对不一样的职场干货:大厂最佳实践经验指南 📆 最近更新:2023年4月15日 🍊 新专栏筹备中,还是熟悉的源码,还是熟悉的感觉! 🍊 点赞 👍 收藏 ⭐留言 📝 都是我最大的动力

    2023年04月18日
    浏览(50)
  • RocketMQ 消费者Rebalance算法 解析——图解、源码级解析

    🍊 Java学习:Java从入门到精通总结 🍊 深入浅出RocketMQ设计思想:深入浅出RocketMQ设计思想 🍊 绝对不一样的职场干货:大厂最佳实践经验指南 📆 最近更新:2022年10月15日 🍊 个人简介:通信工程本硕💪、Java程序员🌕。做过科研paper,发过专利,优秀的程序员不应该只是

    2024年01月19日
    浏览(41)
  • Ribbon 负载均衡策略 —— 图解、源码级解析

    🍊 Java学习:社区快速通道 🍊 深入浅出RocketMQ设计思想:深入浅出RocketMQ设计思想 🍊 绝对不一样的职场干货:大厂最佳实践经验指南 📆 最近更新:2023年6月4日 🍊 点赞 👍 收藏 ⭐留言 📝 都是我最大的动力! 通过本文你可以学习到: 常见的7种负载均衡策略思想 自旋锁

    2024年02月07日
    浏览(35)
  • 1.3 eureka+ribbon,完成服务注册与调用,负载均衡源码追踪

    本篇继先前发布的1.2 eureka注册中心,完成服务注册的内容 。 目录 环境搭建 采用eureka+ribbon的方式,对多个user服务发送请求,并实现负载均衡 负载均衡原理 负载均衡源码追踪 负载均衡策略 如何选择负载均衡策略? 饥饿加载 复制(补充) 给order模块和user模块建立独立的数

    2024年02月14日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包