前言

前情回顾

上一讲看了Eureka 注册中心的自我保护机制，以及里面提到的bug问题。

哈哈 转眼间都2020年了，这个系列的文章从12.17 一直写到现在，也是不容易哈，每天持续不断学习，输出博客，这一段时间确实收获很多。

今天在公司给组内成员分享了Eureka源码剖析，反响效果还可以，也算是感觉收获了点东西。后面还会继续feign、ribbon、hystrix的源码学习，依然文章连载的形式输出。

本讲目录

本讲主要是EurekaServer集群模式的数据同步讲解，主要目录如下。

目录如下：

  1. eureka server集群机制
  2. 注册、下线、续约的注册表同步机制
  3. 注册表同步三层队列机制详解

技术亮点：

  1. 3层队列机制实现注册表的批量同步需求

说明

原创不易，如若转载 请标明来源！

博客地址：一枝花算不算浪漫

微信公众号：壹枝花算不算浪漫

源码分析

eureka server集群机制

Eureka Server会在注册、下线、续约的时候进行数据同步，将信息同步到其他Eureka Server节点。

可以想象到的是，这里肯定不会是实时同步的，往后继续看注册表的同步机制吧。

注册、下线、续约的注册表同步机制

我们以Eureka Client注册为例，看看Eureka Server是如何同步给其他节点的。

PeerAwareInstanceRegistryImpl.java :

  1. public void register(final InstanceInfo info, final boolean isReplication) {
  2.     int leaseDuration = Lease.DEFAULT_DURATION_IN_SECS;
  3.     if (info.getLeaseInfo() != null && info.getLeaseInfo().getDurationInSecs() > 0) {
  4.         leaseDuration = info.getLeaseInfo().getDurationInSecs();
  5.     }
  6.     super.register(info, leaseDuration, isReplication);
  7.     replicateToPeers(Action.Register, info.getAppName(), info.getId(), info, null, isReplication);
  8. }
  10. private void replicateToPeers(Action action, String appName, String id,
  11.                                   InstanceInfo info /* optional */,
  12.                                   InstanceStatus newStatus /* optional */, boolean isReplication) {
  13.     Stopwatch tracer = action.getTimer().start();
  14.     try {
  15.         if (isReplication) {
  16.             numberOfReplicationsLastMin.increment();
  17.         }
  18.         // If it is a replication already, do not replicate again as this will create a poison replication
  19.         if (peerEurekaNodes == Collections.EMPTY_LIST || isReplication) {
  20.             return;
  21.         }
  23.         for (final PeerEurekaNode node : peerEurekaNodes.getPeerEurekaNodes()) {
  24.             // If the url represents this host, do not replicate to yourself.
  25.             if (peerEurekaNodes.isThisMyUrl(node.getServiceUrl())) {
  26.                 continue;
  27.             }
  28.             replicateInstanceActionsToPeers(action, appName, id, info, newStatus, node);
  29.         }
  30.     } finally {
  31.         tracer.stop();
  32.     }
  33. }
  35. private void replicateInstanceActionsToPeers(Action action, String appName,
  36.                                                  String id, InstanceInfo info, InstanceStatus newStatus,
  37.                                                  PeerEurekaNode node) {
  38.     try {
  39.         InstanceInfo infoFromRegistry = null;
  40.         CurrentRequestVersion.set(Version.V2);
  41.         switch (action) {
  42.             case Cancel:
  43.                 node.cancel(appName, id);
  44.                 break;
  45.             case Heartbeat:
  46.                 InstanceStatus overriddenStatus = overriddenInstanceStatusMap.get(id);
  47.                 infoFromRegistry = getInstanceByAppAndId(appName, id, false);
  48.                 node.heartbeat(appName, id, infoFromRegistry, overriddenStatus, false);
  49.                 break;
  50.             case Register:
  51.                 node.register(info);
  52.                 break;
  53.             case StatusUpdate:
  54.                 infoFromRegistry = getInstanceByAppAndId(appName, id, false);
  55.                 node.statusUpdate(appName, id, newStatus, infoFromRegistry);
  56.                 break;
  57.             case DeleteStatusOverride:
  58.                 infoFromRegistry = getInstanceByAppAndId(appName, id, false);
  59.                 node.deleteStatusOverride(appName, id, infoFromRegistry);
  60.                 break;
  61.         }
  62.     } catch (Throwable t) {
  63.         logger.error("Cannot replicate information to {} for action {}", node.getServiceUrl(), action.name(), t);
  64.     }
  65. }
  1. 注册完成后，调用replicateToPeers()，注意这里面有一个参数isReplication，如果是true，代表是其他Eureka Server节点同步的，false则是EurekaClient注册来的。
  2. replicateToPeers()中一段逻辑，如果isReplication为true则直接跳出，这里意思是client注册来的服务实例需要向其他节点扩散，如果不是则不需要去同步
  3. peerEurekaNodes.getPeerEurekaNodes()拿到所有的Eureka Server节点，循环遍历去同步数据，调用replicateInstanceActionsToPeers()
  4. replicateInstanceActionsToPeers()方法中根据注册、下线、续约等去处理不同逻辑

接下来就是真正执行同步逻辑的地方，这里主要用了三层队列对同步请求进行了batch操作，将请求打成一批批 然后向各个EurekaServer进行http请求。

注册表同步三层队列机制详解

到了这里就是真正进入了同步的逻辑，这里还是以上面注册逻辑为主线，接着上述代码继续往下跟：

PeerEurekaNode.java :

  1. public void register(final InstanceInfo info) throws Exception {
  2.     long expiryTime = System.currentTimeMillis() + getLeaseRenewalOf(info);
  3.     batchingDispatcher.process(
  4.             taskId("register", info),
  5.             new InstanceReplicationTask(targetHost, Action.Register, info, null, true) {
  6.                 public EurekaHttpResponse<Void> execute() {
  7.                     return replicationClient.register(info);
  8.                 }
  9.             },
  10.             expiryTime
  11.     );
  12. }

这里会执行batchingDispatcher.process() 方法，我们继续点进去，然后会进入 TaskDispatchers.createBatchingTaskDispatcher() 方法，查看其中的匿名内部类中的process()方法:

  1. void process(ID id, T task, long expiryTime) {
  2.     	// 将请求都放入到acceptorQueue中
  3.         acceptorQueue.add(new TaskHolder<ID, T>(id, task, expiryTime));
  4.         acceptedTasks++;
  5.     }

将需要同步的Task数据放入到acceptorQueue队列中。

接着回到createBatchingTaskDispatcher()方法中，看下AcceptorExecutor，它的构造函数中会启动一个后台线程：

  1. ThreadGroup threadGroup = new ThreadGroup("eurekaTaskExecutors");
  3. this.acceptorThread = new Thread(threadGroup, new AcceptorRunner(), "TaskAcceptor-" + id);

我们继续跟AcceptorRunner.java:

  1. class AcceptorRunner implements Runnable {
  2.     @Override
  3.     public void run() {
  4.         long scheduleTime = 0;
  5.         while (!isShutdown.get()) {
  6.             try {
  7.                 // 处理acceptorQueue队列中的数据
  8.                 drainInputQueues();
  10.                 int totalItems = processingOrder.size();
  12.                 long now = System.currentTimeMillis();
  13.                 if (scheduleTime < now) {
  14.                     scheduleTime = now + trafficShaper.transmissionDelay();
  15.                 }
  16.                 if (scheduleTime <= now) {
  17.                     // 将processingOrder拆分成一个个batch，然后进行操作
  18.                     assignBatchWork();
  19.                     assignSingleItemWork();
  20.                 }
  22.                 // If no worker is requesting data or there is a delay injected by the traffic shaper,
  23.                 // sleep for some time to avoid tight loop.
  24.                 if (totalItems == processingOrder.size()) {
  25.                     Thread.sleep(10);
  26.                 }
  27.             } catch (InterruptedException ex) {
  28.                 // Ignore
  29.             } catch (Throwable e) {
  30.                 // Safe-guard, so we never exit this loop in an uncontrolled way.
  31.                 logger.warn("Discovery AcceptorThread error", e);
  32.             }
  33.         }
  34.     }
  36.     private void drainInputQueues() throws InterruptedException {
  37.         do {
  38.             drainAcceptorQueue();
  40.             if (!isShutdown.get()) {
  41.                 // If all queues are empty, block for a while on the acceptor queue
  42.                 if (reprocessQueue.isEmpty() && acceptorQueue.isEmpty() && pendingTasks.isEmpty()) {
  43.                     TaskHolder<ID, T> taskHolder = acceptorQueue.poll(10, TimeUnit.MILLISECONDS);
  44.                     if (taskHolder != null) {
  45.                         appendTaskHolder(taskHolder);
  46.                     }
  47.                 }
  48.             }
  49.         } while (!reprocessQueue.isEmpty() || !acceptorQueue.isEmpty() || pendingTasks.isEmpty());
  50.     }
  52.     private void drainAcceptorQueue() {
  53.         while (!acceptorQueue.isEmpty()) {
  54.             // 将acceptor队列中的数据放入到processingOrder队列中去，方便后续拆分成batch
  55.             appendTaskHolder(acceptorQueue.poll());
  56.         }
  57.     }
  59.     private void appendTaskHolder(TaskHolder<ID, T> taskHolder) {
  60.         if (isFull()) {
  61.             pendingTasks.remove(processingOrder.poll());
  62.             queueOverflows++;
  63.         }
  64.         TaskHolder<ID, T> previousTask = pendingTasks.put(taskHolder.getId(), taskHolder);
  65.         if (previousTask == null) {
  66.             processingOrder.add(taskHolder.getId());
  67.         } else {
  68.             overriddenTasks++;
  69.         }
  70.     }
  72. }

认真跟这里面的代码，可以看到这里是将上面的acceptorQueue放入到processingOrder, 其中processingOrder也是一个队列。

在AcceptorRunner.java的run()方法中，还会调用assignBatchWork()方法，这里面就是将processingOrder打成一个个batch，接着看代码：

  1. void assignBatchWork() {
  2.             if (hasEnoughTasksForNextBatch()) {
  3.                 if (batchWorkRequests.tryAcquire(1)) {
  4.                     long now = System.currentTimeMillis();
  5.                     int len = Math.min(maxBatchingSize, processingOrder.size());
  6.                     List<TaskHolder<ID, T>> holders = new ArrayList<>(len);
  7.                     while (holders.size() < len && !processingOrder.isEmpty()) {
  8.                         ID id = processingOrder.poll();
  9.                         TaskHolder<ID, T> holder = pendingTasks.remove(id);
  10.                         if (holder.getExpiryTime() > now) {
  11.                             holders.add(holder);
  12.                         } else {
  13.                             expiredTasks++;
  14.                         }
  15.                     }
  16.                     if (holders.isEmpty()) {
  17.                         batchWorkRequests.release();
  18.                     } else {
  19.                         batchSizeMetric.record(holders.size(), TimeUnit.MILLISECONDS);
  20.                         // 将批量数据放入到batchWorkQueue中
  21.                         batchWorkQueue.add(holders);
  22.                     }
  23.                 }
  24.             }
  25.         }
  27.         private boolean hasEnoughTasksForNextBatch() {
  28.             if (processingOrder.isEmpty()) {
  29.                 return false;
  30.             }
  31.             // 默认maxBufferSize为250
  32.             if (pendingTasks.size() >= maxBufferSize) {
  33.                 return true;
  34.             }
  36.             TaskHolder<ID, T> nextHolder = pendingTasks.get(processingOrder.peek());
  37.             // 默认maxBatchingDelay为500ms
  38.             long delay = System.currentTimeMillis() - nextHolder.getSubmitTimestamp();
  39.             return delay >= maxBatchingDelay;
  40.         }

这里加入batch的规则是：maxBufferSize 默认为250

maxBatchingDelay 默认为500ms，打成一个个batch后就开始发送给server端。至于怎么发送 我们接着看 PeerEurekaNode.java， 我们在最开始调用register() 方法就是调用PeerEurekaNode.register(), 我们来看看它的构造方法：

  1. PeerEurekaNode(PeerAwareInstanceRegistry registry, String targetHost, String serviceUrl,
  2.                                      HttpReplicationClient replicationClient, EurekaServerConfig config,
  3.                                      int batchSize, long maxBatchingDelayMs,
  4.                                      long retrySleepTimeMs, long serverUnavailableSleepTimeMs) {
  5.     this.registry = registry;
  6.     this.targetHost = targetHost;
  7.     this.replicationClient = replicationClient;
  9.     this.serviceUrl = serviceUrl;
  10.     this.config = config;
  11.     this.maxProcessingDelayMs = config.getMaxTimeForReplication();
  13.     String batcherName = getBatcherName();
  14.     ReplicationTaskProcessor taskProcessor = new ReplicationTaskProcessor(targetHost, replicationClient);
  15.     this.batchingDispatcher = TaskDispatchers.createBatchingTaskDispatcher(
  16.             batcherName,
  17.             config.getMaxElementsInPeerReplicationPool(),
  18.             batchSize,
  19.             config.getMaxThreadsForPeerReplication(),
  20.             maxBatchingDelayMs,
  21.             serverUnavailableSleepTimeMs,
  22.             retrySleepTimeMs,
  23.             taskProcessor
  24.     );
  25. }

这里会实例化一个ReplicationTaskProcessor.java， 我们跟进去，发下它是实现TaskProcessor的，所以一定会执行此类中的process()方法，执行方法如下：

  1. public ProcessingResult process(List<ReplicationTask> tasks) {
  2.     ReplicationList list = createReplicationListOf(tasks);
  3.     try {
  4.         EurekaHttpResponse<ReplicationListResponse> response = replicationClient.submitBatchUpdates(list);
  5.         int statusCode = response.getStatusCode();
  6.         if (!isSuccess(statusCode)) {
  7.             if (statusCode == 503) {
  8.                 logger.warn("Server busy (503) HTTP status code received from the peer {}; rescheduling tasks after delay", peerId);
  9.                 return ProcessingResult.Congestion;
  10.             } else {
  11.                 // Unexpected error returned from the server. This should ideally never happen.
  12.                 logger.error("Batch update failure with HTTP status code {}; discarding {} replication tasks", statusCode, tasks.size());
  13.                 return ProcessingResult.PermanentError;
  14.             }
  15.         } else {
  16.             handleBatchResponse(tasks, response.getEntity().getResponseList());
  17.         }
  18.     } catch (Throwable e) {
  19.         if (isNetworkConnectException(e)) {
  20.             logNetworkErrorSample(null, e);
  21.             return ProcessingResult.TransientError;
  22.         } else {
  23.             logger.error("Not re-trying this exception because it does not seem to be a network exception", e);
  24.             return ProcessingResult.PermanentError;
  25.         }
  26.     }
  27.     return ProcessingResult.Success;
  28. }

这里面是将List<ReplicationTask> tasks 通过submitBatchUpdate() 发送给server端。

server端在PeerReplicationResource.batchReplication()去处理，实际上就是循环调用ApplicationResource.addInstance() 方法，又回到了最开始注册的方法。

到此 EurekaServer同步的逻辑就结束了，这里主要是三层队列的数据结构很绕，通过一个batchList去批量同步数据的。

注意这里还有一个很重要的点，就是Client注册时调用addInstance()方法，这里到了server端PeerAwareInstanceRegistryImpl会执行同步其他EurekaServer逻辑。

而EurekaServer同步注册接口仍然会调用addInstance()方法，这里难不成就死循环调用了？当然不是，addInstance()中也有个参数：isReplication， 在最后调用server端方法的时候如下：registry.register(info, "true".equals(isReplication));

我们知道，EurekaClient在注册的时候isReplication传递为空，所以这里为false，而Server端同步的时候调用：

PeerReplicationResource:

  1. private static Builder handleRegister(ReplicationInstance instanceInfo, ApplicationResource applicationResource) {
  2.         applicationResource.addInstance(instanceInfo.getInstanceInfo(), REPLICATION);
  3.         return new Builder().setStatusCode(Status.OK.getStatusCode());
  4.     }

这里的REPLICATION 为true

另外在AbstractJersey2EurekaHttpClient中发送register请求的时候，有个addExtraHeaders()方法，如下图：

如果是使用的Jersey2ReplicationClient发送的，那么header中的x-netflix-discovery-replication配置则为true，在后面执行注册的addInstance()方法中会接收这个参数的：

总结

仍然一图流，文中解析的内容都包含在这张图中了：

申明

本文章首发自本人博客：https://www.cnblogs.com/wang-meng 和公众号：壹枝花算不算浪漫，如若转载请标明来源!

感兴趣的小伙伴可关注个人公众号：壹枝花算不算浪漫

【一起学源码-微服务】Nexflix Eureka 源码十二：EurekaServer集群模式源码分析的更多相关文章

  1. 微服务管理平台nacos虚拟ip负载均衡集群模式搭建

    一.Nacos简介 Nacos是用于微服务管理的平台,其核心功能是服务注册与发现.服务配置管理. Nacos作为服务注册发现组件,可以替换Spring Cloud应用中传统的服务注册于发现组件,如:E ...

  2. 【一起学源码-微服务】Eureka+Ribbon+Feign阶段性总结

    前言 想说的话 这里已经梳理完Eureka.Ribbon.Feign三大组件的基本原理了,今天做一个总结,里面会有一个比较详细的调用关系流程图. 说明 原创不易,如若转载 请标明来源! 博客地址:一枝 ...

  3. Spring Boot + Spring Cloud 构建微服务系统（六）：熔断监控集群（Turbine）

    Spring Cloud Turbine 上一章我们集成了Hystrix Dashboard,使用Hystrix Dashboard可以看到单个应用内的服务信息,显然这是不够的,我们还需要一个工具能让 ...

  4. spring cloud微服务快速教程之（十二） 分布式ID解决方案（mybatis-plus篇）

    0-前言 分布式系统中,分布式ID是个必须解决的问题点: 雪花算法是个好方式,不过不能直接使用,因为如果直接使用的话,需要配置每个实例workerId和datacenterId,在微服务中,实例一般动 ...

  5. .Net Core微服务——Consul（4）：主从、集群

    延续上一篇的话题继续,顺便放上一篇的传送门:点这里. 集群的必要性 consul本身就是管理集群的,现在还需要给consul搞个集群,这是为啥?因为consul单点也容易挂啊!万一管理集群的consu ...

  6. 【Azure微服务 Service Fabric 】如何转移Service Fabric集群中的种子节点(Seed Node)

    注意:在对Service Fabric的节点做操作之前,请务必确认是否是种子节点(Seed Node)且当前节点的数量是否与SF的持久层要求的数量一致. 可靠性级别是 Service Fabric 群 ...

  7. 【一起学源码-微服务】Nexflix Eureka 源码十三：Eureka源码解读完结撒花篇~！

    前言 想说的话 [一起学源码-微服务-Netflix Eureka]专栏到这里就已经全部结束了. 实话实说,从最开始Eureka Server和Eureka Client初始化的流程还是一脸闷逼,到现 ...

  8. 【一起学源码-微服务】Nexflix Eureka 源码十：服务下线及实例摘除，一个client下线到底多久才会被其他实例感知？

    前言 前情回顾 上一讲我们讲了 client端向server端发送心跳检查,也是默认每30钟发送一次,server端接收后会更新注册表的一个时间戳属性,然后一次心跳(续约)也就完成了. 本讲目录 这一 ...

  9. 【一起学源码-微服务】Nexflix Eureka 源码五：EurekaClient启动要经历哪些艰难险阻？

    前言 在源码分析三.四都有提及到EurekaClient启动的一些过程.因为EurekaServer在集群模式下 自己本身就是一个client,所以之前初始化eurekaServerContext就有 ...

随机推荐

  1. 【vb.net机房收费系统】之没有包含要从继承的组件的已生成程序集 标签： vb.net继承 2015-05-02 15:19 1012人阅读

    在敲到组合查询这个功能的时候,需要用到窗体的继承,但是在新建继承窗体的时候,出现了错误(没有包含要从继承的组件的已生成程序集).如下图: 问题的产生:当时没怎么注意,也不知道怎么弄的,最后反正是继承上 ...

  2. 终端安装opencv

    安装 要想在 notebook 中安装和使用 OpenCV,请打开终端窗口(也被称为 Windows 用户的命令提示符窗口),并使用以下命令通过 conda 安装最新版本 (v3): conda in ...

  3. 仿IOS效果-带弹簧动画的ListView

    背景介绍 最近项目打算做一个界面,类似于dayone首页的界面效果,dayone 是一款付费应用,目前只有IOS端.作为一个资深懒惰的程序员,奉行的宗旨是绝对不重复造一个轮子.于是乎,去网上找一大堆开 ...

  4. hdu 5793 A Boring Question（2016第六场多校）

    A Boring Question Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others ...

  5. Mybatis/Ibatis，数据库操作的返回值

    该问题,我百度了下,根本没发现什么有价值的文章:还是看源代码(详见最后附录)中的注释,最有效了!insert,返回值是:新插入行的主键(primary key):需要包含<selectKey&g ...

  6. Android教程-03 常见布局的总结

    常见的布局 视频建议采用超清模式观看, 欢迎点击订阅我的优酷 Android的图形用户界面是由多个View和ViewGroup构建出来的.View是通用的UI窗体小组件,比如按钮(Button)或者文 ...

  7. AUTOSSH设置ssh隧道，实现反向代理访问内网主机

    内网主机上配置: autossh -M -CNR :localhost: ubuntu@123.207.121.121 可以实现将访问主机123.207.121.121的1234端口的数据,通过隧道转 ...

  8. 2018-2-13-win10-uwp-如何让-Page-继承泛型类

    title author date CreateTime categories win10 uwp 如何让 Page 继承泛型类 lindexi 2018-2-13 17:23:3 +0800 201 ...

  9. SuperSocket通过证书文件启用 TLS/SSL

    你需要通过下面的步骤修改配置文件来使用你准备好的证书文件: 在server节点设置security属性: 在server节点下增加certificate子节点: 最后配置应该像这样: <serv ...

  10. JavaScript中判断整数的方法

    一.使用取余运算符判断 任何整数都会被1整除,即余数是0.利用这个规则来判断是否是整数. 1 2 3 4 5 function isInteger(obj) {     return obj%1 == ...