【Nacos源码篇(九)】Nacos的心跳源码剖析

已于 2022-03-02 20:31:40 修改
阅读量1.1w 收藏 4
点赞数 3
分类专栏： Nacos源码 源码 springcloud alibaba 文章标签： java spring cloud eureka
于 2022-02-21 21:24:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pzzzz_wwy/article/details/123055638
版权

本人看的源码版本是nacos2.0.3
不同版本的逻辑大致一致

文章目录

客户端相关代码

还是从客户端注册的地方开始（注册的流程可以参考上一篇）
com.alibaba.nacos.client.naming.remote.http.NamingHttpClientProxy#registerService

    @Override
    public void registerService(String serviceName, String groupName, Instance instance) throws NacosException {
		// ...
        if (instance.isEphemeral()) {
            BeatInfo beatInfo = beatReactor.buildBeatInfo(groupedServiceName, instance);
            beatReactor.addBeatInfo(groupedServiceName, beatInfo);
        }
        //...
    }

省略了服务注册的逻辑，直接看看心跳逻辑
在这里判断了当前的服务是否是 短暂的客户端（默认true），然后构建了一些心跳信息

public class BeatInfo {
    private int port;
    private String ip;
    private double weight;
    private String serviceName;
    private String cluster;
    private Map<String, String> metadata;
    private volatile boolean scheduled;
    private volatile long period;
    private volatile boolean stopped;
    // ignore...
}

⚡️ 如当前实例的端口，IP，权重，服务名，等，需要注意的是period，以及stopped，这两个值的作用是跟心跳的延时以及控制心跳线程有关，后续代码会细化
⚡️ beatReactor.addBeatInfo(groupedServiceName, beatInfo) 向心跳反应堆添加心跳信息（源码稍后分析），后续的心跳的线程相关操作交由 BeatReactor

BeatReactor

下面贴的代码有点多，不过会对每个方法都详细描述（下列代码都是BeatReactor内部的代码）

public class BeatReactor implements Closeable {   
    // ignore..
    private final ScheduledExecutorService executorService;
	public BeatReactor(NamingHttpClientProxy serverProxy, Properties properties) {
        this.serverProxy = serverProxy;
        // 获取合适的线程数
        int threadCount = initClientBeatThreadCount(properties);
        this.executorService = new ScheduledThreadPoolExecutor(threadCount, new ThreadFactory() {
            // ThreadFactory 设置的这个线程为守护线程，意味着该线程不出意外是会一直伴随着实例发送心跳
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                // 设置为守护线程，在没有用户线程可服务时会自动离开
                thread.setDaemon(true);
                thread.setName("com.alibaba.nacos.naming.beat.sender");
                return thread;
            }
        });
    }
    // ignore..
}
首先看看其构造器
public class BeatReactor implements Closeable {   
    // ignore..
    private final ScheduledExecutorService executorService;
	public BeatReactor(NamingHttpClientProxy serverProxy, Properties properties) {
        this.serverProxy = serverProxy;
        // 获取合适的线程数
        int threadCount = initClientBeatThreadCount(properties);
        this.executorService = new ScheduledThreadPoolExecutor(threadCount, new ThreadFactory() {
            // ThreadFactory 设置的这个线程为守护线程，意味着该线程不出意外是会一直伴随着实例发送心跳
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                // 设置为守护线程，在没有用户线程可服务时会自动离开
                thread.setDaemon(true);
                thread.setName("com.alibaba.nacos.naming.beat.sender");
                return thread;
            }
        });
    }
    // ignore..
}

⚡️ 在其构造器中，初始化了一个线程池ScheduledExecutorService（可延迟后运行，或定期执行），其核心线程数为ThreadUtils.getSuitableThreadCount(1) > 1 ? ThreadUtils.getSuitableThreadCount(1) / 2 : 1 通过核数，计算出合适的线程数之和，如果>1，则取一半，不然则返回1
⚡️ 同时，传入的线程工厂设置了其名称，以及其为守护线程，个人理解：线程池通过工厂创建出来的心跳线程均被标记为了守护线程，则说明当所有用户线程（或服务下线）退出的时候，即这个线程会被销毁（这里顺带提一下和后面代码相关的，心跳的时候是每5s都会通过线程池创建新的线程进行心跳包的发送，即发送完心跳就return了，这里标记为守护线程原因可能考虑到这5s内，如果服务down掉，能避免掉这次的心跳包的发送了，【个人理解】）
⚡️ 所以说，心跳反应堆BeatReactor在创建初期，主要是初始化了其心跳的线程池的大小，以及设置了其线程工厂

addBeatInfo
public class BeatReactor implements Closeable {   
    // ignore ..
    private final ScheduledExecutorService executorService;
  	public final Map<String, BeatInfo> dom2Beat = new ConcurrentHashMap<String, BeatInfo>();
    public void addBeatInfo(String serviceName, BeatInfo beatInfo) {
        NAMING_LOGGER.info("[BEAT] adding beat: {} to beat map.", beatInfo);
        // 心跳 key  serviceName#192.168.0.6#8080
        String key = buildKey(serviceName, beatInfo.getIp(), beatInfo.getPort());
        BeatInfo existBeat;
       
        if ((existBeat = dom2Beat.remove(key)) != null) {
            existBeat.setStopped(true);
        }
        dom2Beat.put(key, beatInfo);
        // 添加细心跳任务
        executorService.schedule(new BeatTask(beatInfo), beatInfo.getPeriod(), TimeUnit.MILLISECONDS);
        MetricsMonitor.getDom2BeatSizeMonitor().set(dom2Beat.size());
    }
}

⚡️ 这是在客户端注册的时候调用的方法，即生成心跳任务的地方
⚡️ key serviceName#192.168.0.6#8080 这里的key由 服务名#IP#端口 拼凑而成
⚡️ 向 dom2Beat 这个map添加了当前实例的信息 ， 不过为什么用map来保存还不清楚，毕竟key对于当前客户端/服务而言 是唯一的
⚡️ 向executorService发送了一个心跳任务，以及任务延迟时间（volatile修饰），即实例注册的时候就准备延迟Period的毫秒的时间后开始执行心跳任务的线程
⚡️ MetricsMonitor这个玩意没用过，应该是性能指标监控之类的，有空再看

BeatTask !!!

心跳任务

public class BeatReactor implements Closeable {
    // ignore..
    
	/**
     * 发送心跳信息的线程
     */
    class BeatTask implements Runnable {

        BeatInfo beatInfo;

        public BeatTask(BeatInfo beatInfo) {
            this.beatInfo = beatInfo;
        }

        @Override
        public void run() {
            if (beatInfo.isStopped()) {
                return;
            }
            // 心跳的间隔时间
            long nextTime = beatInfo.getPeriod();
            try {
                // 发送心跳
                JsonNode result = serverProxy.sendBeat(beatInfo, BeatReactor.this.lightBeatEnabled);
                long interval = result.get(CLIENT_BEAT_INTERVAL_FIELD).asLong();
                boolean lightBeatEnabled = false;
                if (result.has(CommonParams.LIGHT_BEAT_ENABLED)) {
                    lightBeatEnabled = result.get(CommonParams.LIGHT_BEAT_ENABLED).asBoolean();
                }
                BeatReactor.this.lightBeatEnabled = lightBeatEnabled;
                if (interval > 0) {
                    nextTime = interval;
                }
                int code = NamingResponseCode.OK;
                if (result.has(CommonParams.CODE)) {
                    code = result.get(CommonParams.CODE).asInt();
                }
                // 未找到请求的资源 则会重试注册
                if (code == NamingResponseCode.RESOURCE_NOT_FOUND) {
                    Instance instance = new Instance();
                    instance.setPort(beatInfo.getPort());
                    instance.setIp(beatInfo.getIp());
                    instance.setWeight(beatInfo.getWeight());
                    instance.setMetadata(beatInfo.getMetadata());
                    instance.setClusterName(beatInfo.getCluster());
                    instance.setServiceName(beatInfo.getServiceName());
                    instance.setInstanceId(instance.getInstanceId());
                    instance.setEphemeral(true);
                    try {
                        serverProxy.registerService(beatInfo.getServiceName(),
                                NamingUtils.getGroupName(beatInfo.getServiceName()), instance);
                    } catch (Exception ignore) {
                    }
                }
            } catch (NacosException ex) {
                NAMING_LOGGER.error("[CLIENT-BEAT] failed to send beat: {}, code: {}, msg: {}",
                        JacksonUtils.toJson(beatInfo), ex.getErrCode(), ex.getErrMsg());

            } catch (Exception unknownEx) {
                NAMING_LOGGER.error("[CLIENT-BEAT] failed to send beat: {}, unknown exception msg: {}",
                        JacksonUtils.toJson(beatInfo), unknownEx.getMessage(), unknownEx);
            } finally {
                // 再次提交一个检测心跳的线程任务 ！ 时间为 nextTime = period
                // 因为每次都是使用的一个新的线程  通过beatInfo的volatile(保证线程可见)修饰的stopped
                // 来判断心跳是否需要终止
                executorService.schedule(new BeatTask(beatInfo), nextTime, TimeUnit.MILLISECONDS);
            }
        }
    }

⚡️ 直接看BeatTask这个线程的run方法，首先会看到对BeatInfo的stopped字段的判断，检验当前心跳是否需要执行（该字段volatile修饰，private volatile boolean stopped;因为这涉及到多个线程共享一个变量了）
⚡️ 发送心跳serverProxy.sendBeat(beatInfo, BeatReactor.this.lightBeatEnabled); 里面的代码待会接着看，先梳理这个心跳的线程内容
⚡️ nextTime即心跳间隔时间，第一次是客户端指定或者默认的，之后会获取从服务端响应的心跳间隔时间CLIENT_BEAT_INTERVAL_FIELD，服务端默认的其实也是5s，待会讲服务端的时候会贴
⚡️ 当客户端返回的code码为 code == NamingResponseCode.RESOURCE_NOT_FOUND （The requested resource is not found.）的时候，会重新服务注册的逻辑，registerService这个方法
⚡️ 在finally代码块里，向线程池提交一个新的心跳任务！！！
⚡️ 简单的总结一下就是，客户端的心跳是通过线程池来发送心跳的，每次心跳发送完都会向线程池提交一个新的心跳任务

NamingHttpClientProxy

sendBeat

这里就是上面的BeatReactor的BeatTask调用发送心跳sendBeat的方法

    /**
     * Send beat.
     */
    public JsonNode sendBeat(BeatInfo beatInfo, boolean lightBeatEnabled) throws NacosException {
        if (NAMING_LOGGER.isDebugEnabled()) {
            NAMING_LOGGER.debug("[BEAT] {} sending beat to server: {}", namespaceId, beatInfo.toString());
        }
        Map<String, String> params = new HashMap<String, String>(16);
        Map<String, String> bodyMap = new HashMap<String, String>(2);
        if (!lightBeatEnabled) { // lightBeatEnabled = false
            bodyMap.put("beat", JacksonUtils.toJson(beatInfo));
        }
        params.put(CommonParams.NAMESPACE_ID, namespaceId);
        params.put(CommonParams.SERVICE_NAME, beatInfo.getServiceName());
        params.put(CommonParams.CLUSTER_NAME, beatInfo.getCluster());
        params.put(IP_PARAM, beatInfo.getIp());
        params.put(PORT_PARAM, String.valueOf(beatInfo.getPort()));
        // /nacos/v1/ns/instance/beat   -- PUT请求
        String result = reqApi(UtilAndComs.nacosUrlBase + "/instance/beat", params, bodyMap, HttpMethod.PUT);
        return JacksonUtils.toObj(result);
    }

⚡️ 包装了一下当前实例的一些信息 beatInfo
⚡️ PUT 请求接口/nacos/v1/ns/instance/beat

服务端相关代码

beat

这里是服务端处理心跳请求的controller
com.alibaba.nacos.naming.controllers.InstanceController#beat

    /**
     * 客户端上报心跳信息的地方
     */
    @CanDistro
    @PutMapping("/beat")
    @Secured(parser = NamingResourceParser.class, action = ActionTypes.WRITE)
    public ObjectNode beat(HttpServletRequest request) throws Exception {
        
        ObjectNode result = JacksonUtils.createEmptyJsonNode();
        result.put(SwitchEntry.CLIENT_BEAT_INTERVAL, switchDomain.getClientBeatInterval());
        
        String beat = WebUtils.optional(request, "beat", StringUtils.EMPTY);
        RsInfo clientBeat = null;
        if (StringUtils.isNotBlank(beat)) {
            clientBeat = JacksonUtils.toObj(beat, RsInfo.class);
        }
        String clusterName = WebUtils
                .optional(request, CommonParams.CLUSTER_NAME, UtilsAndCommons.DEFAULT_CLUSTER_NAME);
        String ip = WebUtils.optional(request, "ip", StringUtils.EMPTY);
        int port = Integer.parseInt(WebUtils.optional(request, "port", "0"));
        if (clientBeat != null) {
            if (StringUtils.isNotBlank(clientBeat.getCluster())) {
                clusterName = clientBeat.getCluster();
            } else {
                // fix #2533
                clientBeat.setCluster(clusterName);
            }
            ip = clientBeat.getIp();
            port = clientBeat.getPort();
        }
        String namespaceId = WebUtils.optional(request, CommonParams.NAMESPACE_ID, Constants.DEFAULT_NAMESPACE_ID);
        String serviceName = WebUtils.required(request, CommonParams.SERVICE_NAME);
        NamingUtils.checkServiceNameFormat(serviceName);
        Loggers.SRV_LOG.debug("[CLIENT-BEAT] full arguments: beat: {}, serviceName: {}, namespaceId: {}", clientBeat,
                serviceName, namespaceId);
        BeatInfoInstanceBuilder builder = BeatInfoInstanceBuilder.newBuilder();
        // 对请求做一些操作 用于处理 1.x 客户端的某些指定请求
        builder.setRequest(request);
        // 处理心跳
        int resultCode = getInstanceOperator()
                .handleBeat(namespaceId, serviceName, ip, port, clusterName, clientBeat, builder);
        result.put(CommonParams.CODE, resultCode);
        result.put(SwitchEntry.CLIENT_BEAT_INTERVAL,
                getInstanceOperator().getHeartBeatInterval(namespaceId, serviceName, ip, port, clusterName));
        result.put(SwitchEntry.LIGHT_BEAT_ENABLED, switchDomain.isLightBeatEnabled());
        return result;
    }

⚡️ 首先做的是根据传入的心跳信息，获取一些相关的参数
⚡️ 不过主要处理服务端接收到心跳逻辑的地方是第41行的handleBeat
⚡️ 同时返回了 CLIENT_BEAT_INTERVAL 即心跳间隔时间，回传给客户端的，对应了BeatTask里的获取nextTime

handleBeat

    public int handleBeat(String namespaceId, String serviceName, String ip, int port, String cluster,
            RsInfo clientBeat, BeatInfoInstanceBuilder builder) throws NacosException {
        Service service = getService(namespaceId, serviceName, true);
        String clientId = IpPortBasedClient.getClientId(ip + InternetAddressUtil.IP_PORT_SPLITER + port, true);
        //拿到客户端的信息
        IpPortBasedClient client = (IpPortBasedClient) clientManager.getClient(clientId);
        if (null == client || !client.getAllPublishedService().contains(service)) {
            if (null == clientBeat) {
                return NamingResponseCode.RESOURCE_NOT_FOUND;
            }
            Instance instance = builder.setBeatInfo(clientBeat).setServiceName(serviceName).build();
            registerInstance(namespaceId, serviceName, instance);
            client = (IpPortBasedClient) clientManager.getClient(clientId);
        }
        if (!ServiceManager.getInstance().containSingleton(service)) {
            throw new NacosException(NacosException.SERVER_ERROR,
                    "service not found: " + serviceName + "@" + namespaceId);
        }
        if (null == clientBeat) {
            clientBeat = new RsInfo();
            clientBeat.setIp(ip);
            clientBeat.setPort(port);
            clientBeat.setCluster(cluster);
            clientBeat.setServiceName(serviceName);
        }
        ClientBeatProcessorV2 beatProcessor = new ClientBeatProcessorV2(namespaceId, clientBeat, client);
        // 异步 立即执行
        HealthCheckReactor.scheduleNow(beatProcessor);
        client.setLastUpdatedTime();
        return NamingResponseCode.OK;
    }

⚡️ 从ClientManager里面获取到当前客户端信息 IpPortBasedClient
⚡️ 第一个if（第7行） 会判断当前客户端是否存在，不存在则响应 RESOURCE_NOT_FOUND（The requested resource is not found.），并且看当前客户端内的ConcurrentHashMap<Service, InstancePublishInfo> publishers 是否存在当前的服务，如果不存在，则直接调用注册实例的方法
⚡️ 第二个if（第15行）从ServiceManager查看当前服务是否存在，不存在则直接抛出异常
⚡️根据入参，创建了一个任务ClientBeatProcessorV2，并且使用 ScheduledExecutorService 提交一个异步任务
⚡️ 总的来说，这块的代码是拿到当前客户端的信息，并且走了一个异步任务，接下来看看这个异步任务做了些什么？

ClientBeatProcessorV2

com.alibaba.nacos.naming.healthcheck.heartbeat#ClientBeatProcessorV2

public class ClientBeatProcessorV2 implements BeatProcessor {
    private final String namespace;
    private final RsInfo rsInfo;
    private final IpPortBasedClient client;
    public ClientBeatProcessorV2(String namespace, RsInfo rsInfo, IpPortBasedClient ipPortBasedClient) {
        this.namespace = namespace;
        this.rsInfo = rsInfo;
        this.client = ipPortBasedClient;
    }
    
    @Override
    public void run() {
        if (Loggers.EVT_LOG.isDebugEnabled()) {
            Loggers.EVT_LOG.debug("[CLIENT-BEAT] processing beat: {}", rsInfo.toString());
        }
        String ip = rsInfo.getIp();
        int port = rsInfo.getPort();
        String serviceName = NamingUtils.getServiceName(rsInfo.getServiceName());
        String groupName = NamingUtils.getGroupName(rsInfo.getServiceName());
        Service service = Service.newService(namespace, groupName, serviceName, rsInfo.isEphemeral());
        HealthCheckInstancePublishInfo instance = (HealthCheckInstancePublishInfo) client.getInstancePublishInfo(service);
        // 根据之前保存的IP和端口 校验一下还对不对 按道理来说不存在不对的情况吧
        if (instance.getIp().equals(ip) && instance.getPort() == port) {
            if (Loggers.EVT_LOG.isDebugEnabled()) {
                Loggers.EVT_LOG.debug("[CLIENT-BEAT] refresh beat: {}", rsInfo);
            }
            // 设置实例最后一次的心跳检测的时间，并且将状态设置成为健康
            instance.setLastHeartBeatTime(System.currentTimeMillis());
            if (!instance.isHealthy()) {
                instance.setHealthy(true);
                Loggers.EVT_LOG.info("service: {} {POS} {IP-ENABLED} valid: {}:{}@{}, region: {}, msg: client beat ok",
                        rsInfo.getServiceName(), ip, port, rsInfo.getCluster(), UtilsAndCommons.LOCALHOST_SITE);
                NotifyCenter.publishEvent(new ServiceEvent.ServiceChangedEvent(service));
                NotifyCenter.publishEvent(new ClientEvent.ClientChangedEvent(client));
            }
        }
    }
}

⚡️ 这是上面通过线程池调用的异步线程
⚡️ 先获取到当前实例信息 HealthCheckInstancePublishInfo ，校验当前的IP和端口是否正确，不过一般情况下应该都是true的吧，什么情况会出现客户端上报的IP和端口端的信息不对等呢…
⚡️ 接着设置了最后一次心跳时间，同时如果当前实例如果不是healthy状态，则设置成true，最后通过NotifyCenter发布了两个事件，服务修改事件和客户端修改事件

以上，就是心跳机制的流程分析~

Nacos源码篇

语雀版文档

Nacos源码注释

Cocowwy.
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Alibaba：Nacos服务心跳和健康检查源码介绍，springboot自定义注解原理详解
m0_63174529的博客
12-18 1132
//注册实例 serviceManager.registerInstance(namespaceId, serviceName, instance); } //获取服务的信息 Service service = serviceManager.getService(namespaceId, serviceName); if (service == null) { throw new NacosException(NacosException.SERVER_ERROR, "service not found:
nacos 源码解析
11-17
nacos 源码解析，解读和理解nacos 源码解析，可大大提升对分布式应用及微服务理解的能力。 Nacos 支持基于 DNS 和基于 RPC 的服务发现（可以作为springcloud的注册中心）、动态配置服务（可以做配置中心）、动态 ...
Nacos心跳机制解读（含简单源码分析）
一个菜鸡的博客
12-05 1644
心跳机制是一种用于监测和管理微服务可用性的机制，它用来维护注册中心和服务提供者之间的连接状态，并及时更新服务实例的状态信息。心跳机制包括两个主要组件：心跳发送方（客户端）和心跳接收方（服务端）。每隔几分钟发送一个固定信息给服务端，服务端收到后回复一个固定信息如果服务端几分钟内没有收到客户端信息则视客户端断开。发包方可以是客户也可以是服务端心跳发送方（Heartbeat Sender）：每个微服务都会定期发送称为心跳消息的请求到一个中央位置（例如注册中心或负载均衡器）。
nacos核心源码深度剖析
秃了也弱了
05-08 1119
2.x版本：同一个服务下，节点必须是相同的（临时/非临时）。nacos2.0使用大量的事件驱动方式。
(Nacos源码解析三)Nacos 心跳机制源码解析
janyxe的博客
10-17 820
Nacos 心跳机制源码解析 Nacos 默认的CAP理论的AP，只能保证最终一致性，所以需要通过心跳机制来感知服务的上下线状态 核心API 客户端 1、客户端是在注册服务的时候向服务端发起心跳请求 com.alibaba.nacos.client.naming.NacosNamingService#registerInstance(java.lang.String, java.lang.String, com.alibaba.nacos.api.naming.pojo.Instance) @Overri
nacos源码分析-心跳检测(服务端)
墨家巨子@俏如来
01-16 2079
前面我们讲了《nacos源码分析-服务注册(客户端)》 和 《nacos源码分析-服务注册(服务端)》，主要是讲的服务注册流程，本章节我们来讲服务心跳检测机制。
Nacos源码分析：心跳机制、健康检查、服务发现、AP集群
最新发布
qq_44027353的博客
07-06 886
官方文档：发送某个实例的心跳接口信息心跳机制 在线流程图健康检查在线流程图健康检查： 现在先回到NacosClient进行服务注册时的代码，通过调用方法进行服务注册 再来看类中run()方法具体的实现 接收客户端的心跳接口，该接口找到instance所属的service后，再调用方法进行处理 修改instance的LastBeat时间 健康检查在线流程图健康检查机制是在服务注册的流程中进行的，接下来回忆一下服务注册的流程：NacosClient端通过调用接口发送post请求会往NacosServer端进行服
nacos源码及build出来的jar包
04-14
从git上下载的1.2.0的源码，在本地编译打包成jar包 双击运行 xxx\nacos\distribution\target\nacos-server-1.2.0\nacos\bin 下的startup.cmd即可运行。访问http://localhost:8848/nacos即可进入界面
nacos-2.1.0源码包
06-21
下面我们将深入探讨Nacos的核心组件、功能、设计模式以及源码实现。 1. **核心组件** - **Naming Service**：服务注册与发现模块，允许服务提供者注册自己的服务，并让服务消费者发现这些服务。 - **Config ...
nacos 源码和安装包
08-08
在这个“nacos 源码和安装包”中，你将获得 Nacos 的源代码以及安装所需的文件，这有助于你深入了解其工作原理，并进行定制化开发或者在生产环境中快速部署。 **Nacos 的核心功能：** 1. **服务注册与发现**：...
nacos.rar源码
08-11
Nacos 源码分析将帮助我们深入了解其内部工作原理，这对于开发者优化系统性能、定制功能或者进行二次开发具有重要意义。 首先，让我们从整体上了解 Nacos 的架构。Nacos 采用 Client-Server 架构，客户端通过 ...
【Nacos源码系列】Nacos心跳机制原理
做一个有思想的技术人
08-01 3012
Nacos心跳机制原理
Alibaba：Nacos服务心跳和健康检查源码介绍，系统盘点Java开发者必须掌握的知识点
2301_79054215的博客
03-31 850
2021年的金三银四一眨眼就到了，对于很多人来说是跳槽的好机会，大厂面试远没有我们想的那么困难，摆好心态，做好准备，你也可以的。另外，面试中遇到不会的问题不妨尝试讲讲自己的思路，因为有些问题不是考察我们的编程能力，而是逻辑思维表达能力；最后平时要进行自我分析与评价，做好职业规划，不断摸索，提高自己的编程能力和抽象思维能力。BAT面试经验实战系列：Spring全家桶+Redis等其他相关的电子书：源码+调优7498503)]BAT面试经验实战系列：Spring全家桶+Redis等。
Nacos源码阅读系列2(心跳机制及健康监测)
qq_38526245的博客
11-22 297
nacos心跳机制及健康监测
（二）微服务中间键工作原理——nacos服务端服务注册心跳包(/nacos/v1/ns/instance/beat)源码解读
厉害哥哥的博客
06-02 1477
上节内容我们通过分析nacos客户端源码，了解了nacos客户端是如何向服务端注册服务和发送心跳包的，本节内容话接上一节内容，我们通过分析nacos服务的源码，查看服务端是如何处理客户端注册时候的心跳包的。
三 nacos注册中心源码解析--心跳机制
Instanceztt的博客
06-29 597
Nacos 默认的CAP理论的AP，只能保证最终一致性，所以需要通过心跳机制来感知服务的上下线状态在前面我们分析服务注册的时候就发现,在客户端注册时就会触发心跳机制,源码如下: com.alibaba.nacos.client.naming.NacosNamingService#registerInstance 1.1 构建心跳基础信息 1.2 开启定时心跳任务 1.3 间隔五秒发送心跳信息 二 服务端处理心跳机制com.alibaba.nacos.naming.controllers.Instanc
Nacos源码BeatReactor
Leon_Jinhai_Sun的博客
11-27 239
而BeatReactor这个类则维护了一个线程池： 当调用BeatReactor的.addBeatInfo(groupedServiceName, beatInfo)方法时，就会执行心跳： public void addBeatInfo(String serviceName, BeatInfo beatInfo) { NAMING_LOGGER.info("[BEAT] adding beat: {} to beat map.", beatInfo); String key = b
0202心跳和服务续约源码解析-nacos2.x-微服务架构
gaogzhen的博客
04-15 832
0202心跳和服务续约源码解析-nacos2.x-微服务架构
Nacos---服务心跳
weixin_60786515的博客
02-05 2658
Nacos---服务心跳
springboot nacos源码
09-09
Spring Boot Nacos 源码可以在 GitHub 上找到。Nacos 是一个用于动态服务发现、配置管理和服务管理的开源平台，而 Spring Boot Nacos 则是在 Spring Boot 框架上集成了 Nacos 的功能。 你可以访问以下链接查看 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值