1.负载均衡,实现轮询机制 2.路由命中的几率分析

最新推荐文章于 2024-04-15 10:25:23 发布
最新推荐文章于 2024-04-15 10:25:23 发布
阅读量258 收藏
点赞数
分类专栏： 负载均衡 路由
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sunxn1991/article/details/103479894
版权

一、代码实现

详见 我的github：https://github.com/sunxiaoning90/com_live_test

 

二、测试结果

10次访问

1W次访问

 

package com.live.test.api.core.serverloadbalance.routeAcc;
   
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.concurrent.ConcurrentHashMap;
   
  import com.alibaba.fastjson.JSONArray;
  import com.alibaba.fastjson.JSONObject;
   
  /**
  * 路由访问 对象
  *
  * @author live
  * @2019年12月9日 @下午2:46:59
  */
  public class RouteAcc {
  private Map<String, RouteNodeAcc> accMap;// route:routeNodeAcc
  private String route;// 路由 module.service.method
  private String keepCountRouteNode;// 连续命中最大值是哪个路由节点 module.service.method.server
  private long keepCount;// 连续命中最大值
  private long count;// 命中总数
  private String last;// 最后一次命中哪个路由节点:module.service.method.server
   
  private RouteAcc() {
  this.accMap = new ConcurrentHashMap<String, RouteNodeAcc>();
  }
   
  public RouteAcc(String route) {
  this();
  this.setRoute(route);
  }
   
  public String getRoute() {
  return route;
  }
   
  public void setRoute(String abc) {
  this.route = abc;
  }
   
  public String getLast() {
  return last;
  }
   
  public void setLast(String last) {
  this.last = last;
  }
   
  public void put(String route) {
  this.incrementCount();
   
  RouteNodeAcc acc;
  if (!this.accMap.containsKey(route)) {
  acc = new RouteNodeAcc(route);
  this.accMap.put(route, acc);
  } else {
  acc = this.accMap.get(route);
  }
  acc.incrementCount();
   
  if (route.equals(this.getLast())) {
  acc.incrementKeepCountTmp();
  } else {
  this.setLast(route);// 设置最后一次访问
  accMap.get(route).setKeepCountTmpReset();
  }
   
  if (acc.getKeepCount() > this.getKeepCount()) {// 设置命中最大值
  this.setKeepCountAbcd(acc.getRouteNode());
  this.setKeepCount(acc.getKeepCount());
  }
  }
   
  public String getKeepCountRouteNode() {
  return keepCountRouteNode;
  }
   
  public void setKeepCountAbcd(String keepCount) {
  this.keepCountRouteNode = keepCount;
  }
   
  public long getKeepCount() {
  return keepCount;
  }
   
  public void setKeepCount(long keepCount) {
  this.keepCount = keepCount;
  }
   
  public long getCount() {
  return count;
  }
   
  public void setCount(long count) {
  this.count = count;
  }
   
  public void incrementCount() {
  this.setCount(this.getCount() + 1);
  }
   
  public JSONObject toJson() {
  JSONObject json = new JSONObject();
  json.put("route(路由)", this.getRoute());
  json.put("count(命中总数)", this.getCount());
  json.put("keepCountRouteNode(最高连续命中路由节点)", this.getKeepCountRouteNode());
  json.put("keepCount(最高连续命中计数器)", this.getKeepCount());
   
  JSONArray accArray = new JSONArray();
  Iterator<Entry<String, RouteNodeAcc>> iterator = this.accMap.entrySet().iterator();
  while (iterator.hasNext()) {
  Entry<String, RouteNodeAcc> next = iterator.next();
  JSONObject accJson = new JSONObject();
  accJson.put(next.getKey(), next.getValue().toJson());
  accArray.add(accJson);
  }
  json.put("routeNodeAcc", accArray);
   
  return json;
  }
  }

 74  ...core/src/main/java/com/live/test/api/core/serverloadbalance/routeAcc/RouteAccManager.java 

  @@ -0,0 +1,74 @@
  package com.live.test.api.core.serverloadbalance.routeAcc;
   
  import java.util.Date;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.concurrent.ConcurrentHashMap;
   
  import com.alibaba.fastjson.JSONArray;
  import com.alibaba.fastjson.JSONObject;
   
  /**
  * 路由访问管理
  *
  * @author live
  * @2019年12月3日 @上午11:01:56
  */
  public class RouteAccManager {
   
  /**
  * 路由访问记录: k:v键值对 route: routeAcc
  */
  private Map<String, RouteAcc> accPoMap = new ConcurrentHashMap<String, RouteAcc>();
  private Date date;
   
  private RouteAccManager() {
  setDate(new Date());
  }
   
  public static RouteAccManager getInstance() {
  return SingletonHolder.instance;
  }
   
  private static class SingletonHolder {
  private static RouteAccManager instance = new RouteAccManager();
  }
   
  public void put(String routeNode) {
  String route = routeNode.substring(0, routeNode.lastIndexOf("."));
   
  if (!this.accPoMap.containsKey(route)) {
  this.accPoMap.put(route, new RouteAcc(route));
  }
   
  RouteAcc accPo = this.accPoMap.get(route);
  accPo.put(routeNode);
  }
   
  public Date getDate() {
  return date;
  }
   
  public void setDate(Date date) {
  this.date = date;
  }
   
  @SuppressWarnings("deprecation")
  public JSONObject toJson() {
  JSONObject json = new JSONObject();
  json.put("date(开始时间)", this.getDate().toLocaleString());
   
  JSONArray routeAccArray = new JSONArray();
  Iterator<Entry<String, RouteAcc>> iterator = this.accPoMap.entrySet().iterator();
  while (iterator.hasNext()) {
  Entry<String, RouteAcc> next = iterator.next();
  JSONObject routeAcc = new JSONObject();
  routeAcc.put(next.getKey(), next.getValue().toJson());
  routeAccArray.add(routeAcc);
  }
   
  json.put("routeAccs", routeAccArray);
  return json;
  }
  }

 81  ...pi_core/src/main/java/com/live/test/api/core/serverloadbalance/routeAcc/RouteNodeAcc.java 

  @@ -0,0 +1,81 @@
  package com.live.test.api.core.serverloadbalance.routeAcc;
   
  import com.alibaba.fastjson.JSONObject;
   
  /**
  * 路由节点访问 对象
  *
  * @author live
  * @2019年12月10日 @下午3:26:43
  */
  public class RouteNodeAcc {
   
  private String routeNode;// 路由节点 module.service.method.server
  private long keepCount;// 最高连续命中计数器
  private long count;// 命中总数数计数器
  private long keepCountTmp;// 临时连续命中计数器,当 临时连续命中计数器 大于 最高连续命中计数器时,刷新 最高连续命中计数器
   
  private RouteNodeAcc() {
  }
   
  public RouteNodeAcc(String routeNode) {
  this();
  this.setRouteNode(routeNode);
  }
   
  public String getRouteNode() {
  return routeNode;
  }
   
  public void setRouteNode(String routeNode) {
  this.routeNode = routeNode;
  }
   
  public long getKeepCountTmp() {
  return keepCountTmp;
  }
   
  public void setKeepCountTmp(long keepCountTmp) {
  this.keepCountTmp = keepCountTmp;
  if (keepCountTmp > this.getKeepCount()) {// 当 临时连续命中计数器 大于 最高连续命中计数器时,刷新 最高连续命中计数器
  this.setKeepCount(keepCountTmp);
  }
  }
   
  public void incrementCount() {
  this.setCount(this.getCount() + 1);
  }
   
  public long getKeepCount() {
  return keepCount;
  }
   
  public void setKeepCount(long keepCount) {
  this.keepCount = keepCount;
  }
   
  public long getCount() {
  return count;
  }
   
  public void setCount(long count) {
  this.count = count;
  }
   
  public void setKeepCountTmpReset() {
  this.setKeepCountTmp(0);
  }
   
  public void incrementKeepCountTmp() {
  this.setKeepCountTmp(this.getKeepCountTmp() + 1);
  }
   
  public JSONObject toJson() {
  JSONObject json = new JSONObject();
  json.put("routeNode(路由节点)", routeNode);
  json.put("count(命中总数数计数器)", count);
  json.put("keepCountTmp(临时连续命中计数器)", keepCountTmp);
  json.put("keepCount(最高连续命中计数器)", keepCount);
  return json;
  }
  }

 36  ..._core/src/main/java/com/live/test/api/core/serverloadbalance/serverdispatcher/Client.java 

  @@ -0,0 +1,36 @@
  package com.live.test.api.core.serverloadbalance.serverdispatcher;
   
  import com.live.test.api.core.serverloadbalance.serverdispatcher.impl.PollServerDispatcher;
   
  public class Client {
  public static void main(String[] args) {
  new Client().test1();
  }
   
  private void test1() {
  int min = 1;
  int max = 5;
  IServerDispatcher sd = new PollServerDispatcher(min, max);
   
  new java.lang.Thread(new Runnable() {
   
  @Override
  public void run() {
  for (int i = 1; i <= 10; i++) {
  testGetNext(sd);
  }
  }
  }).start();
   
  for (int i = 1; i <= 10; i++) {
  testGetNext(sd);
  }
  }
   
  private void testGetNext(IServerDispatcher sd) {
  // int next = sd.getNext();
  // long count = sd.getCount();
  // int last = sd.getLast();
  // System.out.println("count:" + count + ",last:" + last + ",next:" + next);
  }
  }

 34  ...ain/java/com/live/test/api/core/serverloadbalance/serverdispatcher/IServerDispatcher.java 

  @@ -0,0 +1,34 @@
  package com.live.test.api.core.serverloadbalance.serverdispatcher;
   
  public interface IServerDispatcher {
   
  /**
  * 初始化最小值
  * @return
  */
  void setMin(int min);
   
  /**
  * 初始化最大值
  * @return
  */
  void setMax(int max);
   
  /**
  * 最后一次取值
  * @return
  */
  int getLast();
   
  /**
  * 下一次取值
  * @return
  */
  int getNext();
   
  /**
  * 自启动后,访问过多少次
  * @return
  */
  long getCount();
  }

 72  .../live/test/api/core/serverloadbalance/serverdispatcher/impl/KeepLastServerDispatcher.java 

  @@ -0,0 +1,72 @@
  package com.live.test.api.core.serverloadbalance.serverdispatcher.impl;
   
  import com.live.test.api.core.serverloadbalance.serverdispatcher.IServerDispatcher;
   
  /**
  * 负载均衡-每次获取上一次的路由:
  * @author live
  * @2019年12月10日 @下午12:22:38
  */
  public class KeepLastServerDispatcher implements IServerDispatcher {
   
  private int max; // max 和 min必须填写
  private int min;
  private int last;
   
  private long count = 0;//自启动后,访问过多少次
   
  public KeepLastServerDispatcher() {
   
  }
   
  public KeepLastServerDispatcher(int min, int max) {
  this();
  this.setMin(min);
  this.setMax(max);
  }
   
  public int getMax() {
  return max;
  }
   
  public int getMin() {
  return min;
  }
   
  @Override
  public void setMin(int min) {
  this.min = min;
  }
   
  @Override
  public void setMax(int max) {
  this.max = max;
  }
   
  @Override
  public int getLast() {
  return this.last;
  }
   
  @Override
  public synchronized int getNext() {
  return this.getLast();
  }
   
  public void setLast(int last) {
  this.last = last;
  }
   
  public long getCount() {
  return count;
  }
   
  public void setCount(long count) {
  this.count = count;
  }
   
  public void incrementCount() {
  this.setCount(this.getCount()+1);
  }
   
  }

 88  .../com/live/test/api/core/serverloadbalance/serverdispatcher/impl/PollServerDispatcher.java 

  @@ -0,0 +1,88 @@
  package com.live.test.api.core.serverloadbalance.serverdispatcher.impl;
   
  import com.live.test.api.core.serverloadbalance.serverdispatcher.IServerDispatcher;
   
  /**
  * 负载均衡-轮询获取路由:1,2,3,1,2,3...
  * @author live
  * @2019年12月10日 @下午12:22:38
  */
  public class PollServerDispatcher implements IServerDispatcher {
   
  private int max; // max 和 min必须填写
  private int min;
  private int last;
   
  private long count = 0;//自启动后,访问过多少次
   
  private PollServerDispatcher() {
   
  }
   
  public PollServerDispatcher(int min, int max) {
  this();
  this.setMin(min);
  this.setMax(max);
  }
   
  public int getMax() {
  return max;
  }
   
  public int getMin() {
  return min;
  }
   
  @Override
  public void setMin(int min) {
  this.min = min;
  }
   
  @Override
  public void setMax(int max) {
  this.max = max;
  }
   
  @Override
  public int getLast() {
  return this.last;
  }
   
  @Override
  public synchronized int getNext() {
  int next ;// 取值
  if(this.getCount() == 0) {// 第一次取值取最小值
  next = this.getMin();
  }else {
  next = this.getLast() + 1;
  }
   
  if (next > this.getMax()) {// 若取值小于最小值,取最小值
  next = this.getMin();
  } else if (next < this.getMin()) {// 若取值小于最小值,取最小值
  next = this.getMin();
  }
   
  System.out.println("上一次概况:count:" + this.getCount() + ",last:" + this.getLast()+",next:" + next);
  this.setLast(next);// 刷新 last
  this.incrementCount();//刷新总数
  return next;
  }
   
  public void setLast(int last) {
  this.last = last;
  }
   
  public long getCount() {
  return count;
  }
   
  public void setCount(long count) {
  this.count = count;
  }
   
  public void incrementCount() {
  this.setCount(this.getCount()+1);
  }
   
  }
大象_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP实现负载均衡的加权轮询方法分析
10-18
主要介绍了PHP实现负载均衡的加权轮询方法,简单描述了常见的负载均衡算法,并结合实例形式分析了加权轮询的相关实现技巧,需要的朋友可以参考下
JSONArray遍历处理
qq_33240556的博客
11-06 8546
json
JsonArray用法讲解
listeningdu的博客
06-06 1万+
这个示例中，首先使用JsonParser将Json字符串解析为JsonArray。然后再使用get方法获取JsonObject中的数据，最终输出解析结果。JsonElement是Json中的基本数据类型，可以是JsonArray、JsonObject、JsonPrimitive或JsonNull。JsonArray是Json中的一个数据类型，本文将讲解JsonArray的用法。这将获取jsonArray中下标为1的JsonElement，即"orange"。这将输出JsonArray中的所有元素。
【Java】JSONArray详解
小賀のBlog
09-25 1万+
JSONArray是一种有序的元素集合，可以包含任意类型的数据，如字符串、数字、布尔值、null、数组或另一个JSON对象。JSONArray在JavaScript和Java等编程语言中都有广泛应用。在JavaScript中，JSONArray是一组数组元素，可以是任何类型的数据，如字符串、数字、布尔值、null、数组或对象。数组元素可以通过索引访问，也可以使用push和pop方法添加或删除元素。在Java中，JSONArray是一个类，用于表示JSON数组。
智能照明-轮询算法
weixin_30340617的博客
11-04 1010
在介绍加权轮询算法(WeightedRound-Robin)之前，首先介绍一下轮询算法(Round-Robin)。 　　 一：轮询算法(Round-Robin) 　　轮询算法是最简单的一种负载均衡算法。它的原理是把来自用户的请求轮流分配给内部的服务器：从服务器1开始，直到服务器N，然后重新开始循环。 　　算法的优点是其简洁性，它无需记录当前所有连接的状态，所以它是一种无状态调...
负载均衡轮询法算法：你真的了解它吗？
最新发布
万猫学社
04-15 718
在本文中，我们详细介绍了负载均衡轮询法算法的基本概念、工作原理以及优缺点。我们可以看出，轮询法是一种简单而有效的负载均衡算法，它将请求按照预定的顺序分配给各个服务器，实现了负载的均衡。然而，轮询法并非万能的，它并不能很好地处理处理能力各异的服务器集群，因此在实际应用中，我们需要根据服务器集群的实际情况，选择最合适的负载均衡算法。在这里，我想引用一句话：“没有银弹。”在计算机科学中，没有一种解决方案是能够解决所有问题的，我们需要根据实际情况，选择最合适的解决方案。
用负载均衡来实现web服务器集群.ppt
11-21
### 负载均衡实现方式 负载均衡的实现通常涉及以下组件： 1. **负载均衡器**：这是核心组件，负责接收所有外部请求，并根据预设策略将请求分发到后端服务器。它可以是硬件设备，如专门的负载均衡硬件，也可以是...
第三讲.负载均衡.docx
09-10
3. 基于IP哈希的负载均衡：通过IP地址的哈希结果决定请求分配给哪个服务器，确保来自同一IP的请求总是被路由到同一台服务器，实现会话持久化。 4. 基于公平（fair）策略：根据后端服务器的响应时间动态分配请求，...
负载均衡算法 — 轮询
努力努力再努力L
01-22 1132
负载均衡算法 — 轮询 目录 概述 简单轮询 加权轮询 平滑加权轮询 1. 概述 在分布式系统中，为了实现负载均衡，必然会涉及到负载调度算法，如 Nginx 和 RPC 服务发现等场景。常见的负载均衡算法有 轮询、源地址 Hash、最少连接数，而 轮询 是最简单且应用最广的算法。 3 种常见的轮询调度算法，分别为 简单轮询、加权轮询、平滑加权轮询。下面将用如下 4 个服务，来详细说明轮询调度过程。 服务实例 权重值 192.168.10.1:2202 1 192.168.10
负载均衡策略 -- 轮询
zhangchen的博客
04-15 3878
详解解释轮询策略
负载均衡轮询算法和服务器性能,SpringCloud-Ribbon负载均衡机制、手写轮询算法
weixin_32296949的博客
08-13 323
Ribbon 内置的负载均衡规则在 com.netflix.loadbalancer 包下有一个接口 IRule，它可以根据特定的算法从服务列表中选取一个要访问的服务，默认使用的是「轮询机制」RoundRobinRule：轮询RandomRule：随机RetryRule：先按照 RoundRobinRule 的策略获取服务，如果获取服务失败则在指定时间内会进行重试，获取可用的服务WeightedR...
最佳路由路径选择算法详解
Mr_Bei的博客
10-22 1万+
动态路由协议基于运行特征可分为 距离矢量协议：RIP、EIGRP、BGP 链路状态协议：OSPF、ISIS   通用的路由选择算法 1.最长匹配原则 2.管理距离 3.度量值 路由路径选择的时候，最先看最长匹配原则，然后再看管理距离，最后看度量值， 若度量值一样，则从最优先的接口同时转发数据，即负载均衡   1.最长匹配原则 定义：将通信目的IP和本地路由条目进行对比，从左...
负载均衡策略之轮询策略
ALakers的博客
08-09 2157
本文转自:https://mozillazg.com/2019/02/load-balancing-strategy-algorithm-weighted-round-robin.html#hidround-robin,尊重原创 前言: 本文简单介绍一下轮询(Round Robin)这个负载均衡策略。 轮询选择 (Round Robin): 轮询选择指的是从已有的后端节点列表中按顺序依次选择一个节点出来提供服务。 一种轮询选择的方法是把所有的节点看做一个一个的点，并把这些点连起来组成一个圆， 轮询选择就是在
linux路由表轮询，只有部分路由目标接到请求
weixin_42584507的博客
01-18 50
在Linux操作系统中，路由表轮询是由路由器使用的一种策略。在这种策略中，路由器会依次检查路由表中的每一项路由目标，并将请求发送到第一个可用的目标。如果第一个目标不可用，则会检查下一项，直到找到一个可用的目标或者检查完所有项。因此，只有部分路由目标会接到请求。 ...
负载均衡算法1--轮询
打酱油的葫芦娃
05-23 7579
轮询算法分为简单轮询(Round-Robin)和加权轮询(Weighted-Round-Robin)。 简单轮询(Round-Robin) 简单轮询是最简单的一种负载均衡算法，其把来自用户的请求轮流分配给内部的服务器:从服务器1开始，直到服务器N，然后重新开始循环。 public class SimpleRoundRobinLoadBalance implements LoadBalance{ private AtomicInteger atomicInteger = new AtomicInte
TCP/IP
weixin_51948279的博客
02-12 1011
TCP/IP原理
循环遍历JSONObject的一种方法
热门推荐
weixin_42205647的博客
07-22 10万+
如果对JSONArray的遍历你能很轻松地实现，那么有可能你对JSONObject的循环遍历却束手无策。 原因就是，JSONArray的遍历可以很轻松地用索引来实现，而JSONObject里，元素却是以"键值对"存在的，即："键名":"键值"结构。 对于这种结构，获取了它的键名（Key）也就能提取出相对应的值了。 下面分享代码(Java)： public class BianliJson ...
JsonObject 遍历
敬畏之心使人进步
07-09 1万+
// com.alibaba.fastjson.JSONObject xmbhScoreJson.forEach((key, value) -> { }); // com.alibaba.fastjson.JSONObject for (Map.Entry<String, Object> entry : xmbhScoreJson.entrySet()) { entry.getKey(); entry.getValue() } // org.json.JS.
edgex 如何实现.负载均衡
05-12
负载均衡器可以根据不同的算法（如轮询、加权轮询、IP散列等）将请求分发给不同的服务实例，从而实现负载均衡。 2. 通过使用服务注册与发现：Edgex使用Consul作为服务注册与发现的工具，可以使用Consul来实现负载...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值