springcloud--Loadbalance的几种算法以及在ribbon中的使用

最新推荐文章于 2024-08-04 13:23:32 发布
最新推荐文章于 2024-08-04 13:23:32 发布
阅读量3.5k 收藏 2
点赞数

Load Balance负载均衡是用于解决一台机器(一个进程)无法解决所有请求而产生的一种算法。

像nginx可以使用负载均衡分配流量，ribbon为客户端提供负载均衡，dubbo服务调用里的负载均衡等等，很多地方都使用到了负载均衡。

使用负载均衡带来的好处很明显：

  1. 当集群里的1台或者多台服务器down的时候，剩余的没有down的服务器可以保证服务的继续使用
  2. 使用了更多的机器保证了机器的良性使用，不会由于某一高峰时刻导致系统cpu急剧上升

负载均衡有好几种实现策略，常见的有：

  1. 随机 (Random)
  2. 轮询 (RoundRobin)
  3. 一致性哈希 (ConsistentHash)
  4. 哈希 (Hash)
  5. 加权（Weighted）

我们以ribbon的实现为基础，看看其中的一些算法是如何实现的。

ribbon是一个为客户端提供负载均衡功能的服务，它内部提供了一个叫做ILoadBalance的接口代表负载均衡器的操作，比如有添加服务器操作、选择服务器操作、获取所有的服务器列表、获取可用的服务器列表等等。

还提供了一个叫做IRule的接口代表负载均衡策略：

1
2
3
4
5
public interface IRule{
     public Server choose(Object key);
     public void setLoadBalancer(ILoadBalancer lb);
     public ILoadBalancer getLoadBalancer();   
}

IRule接口的实现类有以下几种：

image

其中RandomRule表示随机策略、RoundRobin表示轮询策略、WeightedResponseTimeRule表示加权策略、BestAvailableRule表示请求数最少策略等等。

随机策略很简单，就是从服务器中随机选择一个服务器，RandomRule的实现代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public Server choose(ILoadBalancer lb, Object key) {
     if (lb == null ) {
         return null ;
     }
     Server server = null ;
 
     while (server == null ) {
         if (Thread.interrupted()) {
             return null ;
         }
         List<Server> upList = lb.getReachableServers();
         List<Server> allList = lb.getAllServers();
         int serverCount = allList.size();
         if (serverCount == 0 ) {
             return null ;
         }
         int index = rand.nextInt(serverCount); // 使用jdk内部的Random类随机获取索引值index
         server = upList.get(index); // 得到服务器实例
 
         if (server == null ) {
             Thread.yield();
             continue ;
         }
 
         if (server.isAlive()) {
             return (server);
         }
 
         server = null ;
         Thread.yield();
     }
     return server;
}

RoundRobin轮询策略表示每次都取下一个服务器，比如一共有5台服务器，第1次取第1台，第2次取第2台，第3次取第3台，以此类推：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public Server choose(ILoadBalancer lb, Object key) {
     if (lb == null ) {
         log.warn( "no load balancer" );
         return null ;
     }
 
     Server server = null ;
     int count = 0 ;
     while (server == null && count++ < 10 ) { // retry 10 次
         List<Server> reachableServers = lb.getReachableServers();
         List<Server> allServers = lb.getAllServers();
         int upCount = reachableServers.size();
         int serverCount = allServers.size();
 
         if ((upCount == 0 ) || (serverCount == 0 )) {
             log.warn( "No up servers available from load balancer: " + lb);
             return null ;
         }
 
         int nextServerIndex = incrementAndGetModulo(serverCount); // incrementAndGetModulo方法内部使用nextServerCyclicCounter这个AtomicInteger属性原子递增对serverCount取模得到索引值
         server = allServers.get(nextServerIndex); // 得到服务器实例
 
         if (server == null ) {
             Thread.yield();
             continue ;
         }
 
         if (server.isAlive() && (server.isReadyToServe())) {
             return (server);
         }
 
         server = null ;
     }
 
     if (count >= 10 ) {
         log.warn( "No available alive servers after 10 tries from load balancer: "
                 + lb);
     }
     return server;
}

BestAvailableRule策略用来选取最少并发量请求的服务器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public Server choose(Object key) {
     if (loadBalancerStats == null ) {
         return super .choose(key);
     }
     List<Server> serverList = getLoadBalancer().getAllServers(); // 获取所有的服务器列表
     int minimalConcurrentConnections = Integer.MAX_VALUE;
     long currentTime = System.currentTimeMillis();
     Server chosen = null ;
     for (Server server: serverList) { // 遍历每个服务器
         ServerStats serverStats = loadBalancerStats.getSingleServerStat(server); // 获取各个服务器的状态
         if (!serverStats.isCircuitBreakerTripped(currentTime)) { // 没有触发断路器的话继续执行
             int concurrentConnections = serverStats.getActiveRequestsCount(currentTime); // 获取当前服务器的请求个数
             if (concurrentConnections < minimalConcurrentConnections) { // 比较各个服务器之间的请求数，然后选取请求数最少的服务器并放到chosen变量中
                 minimalConcurrentConnections = concurrentConnections;
                 chosen = server;
             }
         }
     }
     if (chosen == null ) { // 如果没有选上，调用父类ClientConfigEnabledRoundRobinRule的choose方法，也就是使用RoundRobinRule轮询的方式进行负载均衡       
         return super .choose(key);
     } else {
         return chosen;
     }
}

实例验证Ribbon中的LoadBalance功能

ServerList中提供了3个instance，分别是：

1
2
3
compute-service: 2222
compute-service: 2223
compute-service: 2224

然后使用不同的IRule策略查看负载均衡的实现。

首先先使用ribbon提供的LoadBalanced注解加在RestTemplate上面，这个注解会自动构造LoadBalancerClient接口的实现类并注册到Spring容器中。

1
2
3
4
5
@Bean
@LoadBalanced
RestTemplate restTemplate() {
     return new RestTemplate();
}

接下来使用RestTemplate进行rest操作的时候，会自动使用负载均衡策略，它内部会在RestTemplate中加入LoadBalancerInterceptor这个拦截器，这个拦截器的作用就是使用负载均衡。

例子中，我们的实例的name叫做compute-service，里面提供了一个方法add用于相加2个Integer类型的数值。

loadbalance的具体操作：

1
2
3
4
5
6
7
8
public String loadbalance() {
     ServiceInstance serviceInstance = loadBalancerClient.choose( "compute-service" );
     StringBuilder sb = new StringBuilder();
     sb.append( "host: " ).append(serviceInstance.getHost()).append( ", " );
     sb.append( "port: " ).append(serviceInstance.getPort()).append( ", " );
     sb.append( "uri: " ).append(serviceInstance.getUri());
     return sb.toString();
}

RandomRule随机策略

RandomRule：

1
2
3
4
5
6
7
8
9
10
11
12
@Configuration
public class RibbonConfiguration {
 
     @Autowired
     private SpringClientFactory springClientFactory;
 
     @Bean
     public IRule ribbonRule() {
         return new RandomRule();
     }
 
}

测试结果如下，确实是随机获取的：

1
2
3
4
5
6
7
8
9
10
host: 192.168 . 31.113 , port: 2222 , uri: http: //192.168.31.113:2222
host: 192.168 . 31.113 , port: 2222 , uri: http: //192.168.31.113:2222
host: 192.168 . 31.113 , port: 2222 , uri: http: //192.168.31.113:2222
host: 192.168 . 31.113 , port: 2224 , uri: http: //192.168.31.113:2224
host: 192.168 . 31.113 , port: 2224 , uri: http: //192.168.31.113:2224
host: 192.168 . 31.113 , port: 2222 , uri: http: //192.168.31.113:2222
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223
host: 192.168 . 31.113 , port: 2222 , uri: http: //192.168.31.113:2222
host: 192.168 . 31.113 , port: 2222 , uri: http: //192.168.31.113:2222
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223

RoundRobinRule轮询策略

RoundRobinRule：

1
2
3
4
@Bean
public IRule ribbonRule() {
     return new RandomRule();
}

测试结果如下，确实是轮询每个服务器的：

1
2
3
4
5
6
7
8
9
10
11
12
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223
host: 192.168 . 31.113 , port: 2222 , uri: http: //192.168.31.113:2222
host: 192.168 . 31.113 , port: 2224 , uri: http: //192.168.31.113:2224
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223
host: 192.168 . 31.113 , port: 2222 , uri: http: //192.168.31.113:2222
host: 192.168 . 31.113 , port: 2224 , uri: http: //192.168.31.113:2224
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223
host: 192.168 . 31.113 , port: 2222 , uri: http: //192.168.31.113:2222
host: 192.168 . 31.113 , port: 2224 , uri: http: //192.168.31.113:2224
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223
host: 192.168 . 31.113 , port: 2222 , uri: http: //192.168.31.113:2222
host: 192.168 . 31.113 , port: 2224 , uri: http: //192.168.31.113:2224

BestAvailableRule最少并发数策略

BestAvailableRule：

1
2
3
4
@Bean
public IRule ribbonRule() {
     return new BestAvailableRule();
}

如果直接访问浏览器的话，测试结果如下(因为每次访问完请求数都变成0，下次遍历永远都是2223这个端口的实例)：

1
2
3
4
5
6
7
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223
host: 192.168 . 31.113 , port: 2223 , uri: http: //192.168.31.113:2223
..

使用wrk模拟并发请求，结果会出现多个实例：

1
wrk -c 1000 -t 10 -d 10s http: //localhost:3333/test
码云_2017
关注
【架构】负载均衡算法-Load Balance
Charles_lnx
12-28 1280
常见负载均衡算法 1、轮询法（Round Robin） 2、加权轮询法（Weight Round Robin） 3、随机法（Random） 4、加权随机法（Weight Random） 5、平滑加权轮询法（Smooth Weight Round Robin） 6、源地址哈希法（Hash） 7、最小连接数法（Least Connections） 8、处理能力均衡(CPU型号和数量、内存大小、当前连接数等多个因子综合衡量) 9、DNS响应均衡（Flash DNS） 1、轮询法（Round
Dubbo 常见的负载均衡(Load Balance)算法,一起学习一下吧~
qq_44405452的博客
09-11 2338
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、负载均衡的目的是什么？二、权重随机算法三.非平滑权重轮询算法平滑权重轮询算法ip hash算法一致性Hash负载均衡算法总结 前言 ????最近学习Dubbo的时候了解到负载均衡相关的内容,随着用户量的增多,数据不断加大,单体应用已不能满足项目的需求,分布式应用就成了我们的解决方案.而且负载均衡算法直接影响了我们分布式应用的性能,本文就dubbo的负载均衡算法来做一些了解吧. 一、负载均衡的目的是什么？ 讨论负载均衡，
科普文：微服务之Spring Cloud 客户端负载均衡组件LoadBalancer替代Ribbon
最新发布
为无为，事无事，味无味。
08-04 892
随着微服务架构的普及，负载均衡器的选择和使用变得尤为重要。 在Spring Cloud生态系统中，Ribbon和Spring Cloud LoadBalancer是两种常用的客户端负载均衡器。 然而，随着Ribbon的停更，Spring Cloud在Hoxton.M2版本中移除了Ribbon，并引入了Spring Cloud LoadBalancer作为替代品。
LoadBalance介绍、使用以及源码分析
在青海看海的企鹅的博客
01-01 2483
import org// 服务列表 private ObjectProvider < ServiceInstanceListSupplier > serviceInstanceListSupplierProvider;} /*** 使用随机数获取服务* @returnSystem . out . println("进来了");} System . out . println("进行随机选取服务");
Dubbo -- 四种loadBalance负载均衡算法
aduglny667985的博客
08-07 476
　　Dubbo中的一个关键接口LoadBalance，dubbo是按照其中的规则来调用多台provider的服务的。 　　先看一下接口的实现类图： 　　 　　从上图中我们可以看到dubbo提供了四种算法来实现负载均衡。 　　1.RandomLoadBalance：随机，按权重设置随机概率。 　　从字面意思也很好理解，根据每个invoker提前设置好的权重随机分配，看一下源码的实...
负载均衡(Load Balance)
云原生Java Web领域技术博客
12-10 2021
现在应用架构使用负载均衡器将客户端的请求路由到不同的应用服务器，以提高系统性能。 一、负载均衡体系结构 多台服务器通过网络设备相连组成一个服务器集群，每台服务器都提供相同或相似的网络服务。服务器集群前端部署一台负载均衡设备，负责根据已配置均衡策略将用户请求在服务器集群中的分发，为用户提供服务，并对服务器可用性的维护。对应体系结构如下： 该结构的优势： (1) 低成本：按照业务量增加服务器个数即可；已有资源不会浪费，新增资源无需选择昂贵的高端设备。 (2) 可扩展性：当业务量增长时，系统可通过增加服务器来满
负载均衡(Loadbalance)
m0_48215210的博客
10-07 1010
负载均衡Loadbalance
SpringCloud自定义负载均衡策略--LoadBalancer
m0_67392931的博客
08-02 933
类必须是类，但请注意，对于主应用程序上下文，它不在中。否则，它由所有共享。如果您使用（或），则需要采取措施避免将其包括在内（例如，可以将其放在单独的，不重叠的程序包中，或指定要在）先贴个目录结构图也就是当前自定义的负载均衡配置文件不能被springboot的启动类给扫描到!否则会有所影响!也不解释了,也没必要,这里不是在探究源码,贴出定义的规则}//??注意这里的两个变量要设为全局变量//每个服务访问5次，然后换下一个服务(3个)@Bean主启动类。...
Spring Cloud Nacos 2021 放弃Ribbon后 使用LoadBalancer + Nacos做负载均衡 实现同集群优先调用以及权重算法
web17886480312的博客
06-12 5198
最近在倒腾SpringBoot整合Nacos最新版，暂时发现以下几个问题以上仅为个人观点，下面为我的实现方式nacos最新版 2021.1版本中 这个包已经不提供ribbon支持，需要引入另一个jar包 使用这个包来实现负载均衡具体实现方式和先前版本一样 注册bean的同时，添加LoadBalanced负载均衡注解，到这一步为止，可以实现基本的负载均衡功能，负载均衡默认配置为轮询配置1.首先需要实现 loadbalancer 自定义 负载均衡模式进行注入一共有两种写法，可以直接在Spring配置文件中注入B
Spring Cloud 之Ribbon核心组件IRule的使用及自定义负载均衡算法
灵越启航
09-09 2427
一、IRule 常见的API Ribbon核心组件IRule中常见的几个算法API，一般情况下，这几个API已经可以满足实际的业务需求了，如下： API 说明 RoundRobinRule 广为人知和最基本的负载平衡策略，即轮询算法。（是Ribbon默认的负载均衡机制） RandomRule 一种随机分配现有流量的负载平衡策略，即随机访问算法 RetryRule 先按照 R...
SpringCloud-1-基础组件（Eureka，Ribbon，Consul）
m0_60875109的博客
07-27 410
SOA全称为Service-OrientedArchitecture，即面向服务的架构。 CAP原理，C：一致性、A可用性，P分区容忍性。 注册中心:Eureka 负载均衡:Ribbon 注册中心替换版本：consul
负载均衡（Load Balance）简单介绍
ilovejava_2010的专栏
07-23 2191
顾名思义，是指将负载进行平衡并分摊到多个操作单元上运行，从而协同完成工作任务。是在网络结构中提供一种扩展网络设备和服务器的带宽、增加网络的吞吐量、加强网络数据处理能力、提高网络灵活性和可用性的软件或硬件结构。 软件 1、基于DNS的负载均衡 由于在DNS服务器中，可以为多个不同的地址配置相同的名字，最终查询这个名字的客户机将在解析这个名字时得到其中一个地址，所以这种代理方式是通过DNS服务中的随机名字解析域名和IP来实现负载均衡。 2、反向代理负载均衡 该种代理方式与普通的代理方式不同，...
常用负载均衡详解
qq_45228323的博客
03-16 1697
在互联网场景下，负载均衡（Load Balance）是分布式系统架构设计中必须考虑的一个环节，它通常是指将负载流量（工作任务、访问请求）平衡、分摊到多个操作单元（服务器、组件）上去执行的过程。 目的在于提供负载配比，解决性能、单点故障（高可用）和扩展性（水平伸缩）等问题。
Ribbon负载均衡（Load Balance）
sunshine543123的博客
08-02 482
LB负载均衡（Load Balance）：将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用） Nginx服务端负载均衡和Ribbon本地负载均衡的区别： Nginx是服务器负载均衡，客户端所有的请求都会交给nginx,然后由nginx实现转发请求。即负载均衡是由服务端实现的。 Ribbon是本地负载均衡，在调用微服务接口的时候，会在注册中心上获取注册信息服务列表之后缓存到JVM本地，从而在本地实现RPC远程服务调用技术。 ...
【Spring Cloud】协同开发利器之动态路由｜Ribbon & LoadBalancer 解析篇
黑白法师的博客
07-11 1546
前段时间我写了一个库，用于解决开发环境中多人协同调试接口的问题：网关转发或服务间调用时会负载均衡到别人的服务，导致调试效率变低功能。今天主要是来讲一讲这个库的实现方式以及Ribbon和LoadBalancer的相关内容......
【JavaWeb】 负载均衡（Load Balance）的5 种算法实现原理
墩墩分墩
06-06 1224
**使用N个服务器平均分担负载，不会因为某个服务器节点负载高宕机而某个节点闲置的情况。那么负载均衡的前提就是要有多个服务器才能实现，也就是两个以上即可。** - **优点**： 减少服务器的压力，将原本一台服务器索要承受的访问量分给多台，并提高项目的可用性，当一台服务器挂掉的时候不会导致项目瘫痪。......
负载均衡（Load Balancing）学习笔记三——负载均衡算法
热门推荐
Leo的博客
01-23 1万+
本文讲述实现负载均衡的常用算法。轮询法（Round Robin）轮询法是负载均衡中最常用的算法，它容易理解也容易实现。 轮询法是指负载均衡服务器（load balancer）将客户端请求按顺序轮流分配到后端服务器上，以达到负载均衡的目的。 假设现在有6个客户端请求，2台后端服务器。当第一个请求到达负载均衡服务器时，负载均衡服务器会将这个请求分派到后端服务器1；当第二个请求到害时，负载均衡服务器会
spring cloud 2020.0.1 LoadBalancer负载均衡算法切换
qq_35799668的博客
03-08 5707
0、前言 这是学习尚硅谷 spring cloud中遇到的一个坑 多看文档地址：[文档地址][https://docs.spring.io/spring-cloud-commons/docs/current/reference/html/#custom-loadbalancer-configuration] 1、spring cloud 2020.0.1 LoadBalancer负载均衡算法切换 springcloud 2020.0.1 版本之后 删除了eureka中的ribbon，替代ribbon的是s
Ribbon负载均衡（三）SpringCloud Ribbon负载均衡详解及实现
流浪的喵的博客
05-24 1241
SpringCloud Ribbon负载均衡实现
SpringCloud-Ribbon：微服务中的客户端负载均衡
"SpringCloud-Ribbon入门案例探讨了Ribbon在微服务中的角色，以及集中式与进程内负载均衡的差异，并给出了一个简单的入门示例。Ribbon作为客户端负载均衡器，实现了Netflix的负载均衡功能，支持多种算法如轮询、随机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值