一.什么是负载均衡
负载均衡(Load-balance LB),指的是将用户的请求平摊分配到各个服务器上,从而达到系统的高可用。常见的负载均衡软件有Nginx、lvs等。
二.负载均衡的简单分类
1)集中式LB:集中式负载均衡指的是,在服务消费者(client)和服务提供者(provider)之间提供负载均衡设施,通过该设施把消费者(client)的请求通过某种策略转发给服务提供者(provider),常见的集中式负载均衡是Nginx;
2)进程式LB:将负载均衡的逻辑集成到消费者(client)身上,即消费者从服务注册中心获取服务列表,获知有哪些地址可用,再从这些地址里选出合适的服务器,springCloud的Ribbon就是一个进程式的负载均衡工具。
三.为什么需要做负载均衡
1) 不做负载均衡,可能导致某台机子负荷太重而挂掉;
2)导致资源浪费,比如某些机子收到太多的请求,肯定会导致某些机子收到很少请求甚至收不到请求,这样会浪费系统资源。
四.springCloud如何开启负载均衡
1)在消费者子工程的pom.xml文件的加入相关依赖(https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-ribbon/1.4.7.RELEASE);
- <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-ribbon -->
- <dependency>
- <groupId>org.springframework.cloud</groupId>
- <artifactId>spring-cloud-starter-ribbon</artifactId>
- <version>1.4.7.RELEASE</version>
- </dependency>
消费者需要获取服务注册中心的注册列表信息,把Eureka的依赖包也放进pom.xml
- <dependency>
- <groupId>org.springframework.cloud</groupId>
- <artifactId>spring-cloud-starter-eureka-server</artifactId>
- <version>1.4.7.RELEASE</version>
- </dependency>
2)在application.yml里配置服务注册中心的信息
在该消费者(client)的application.yml里配置Eureka的信息
- #配置Eureka
- eureka:
- client:
- #是否注册自己到服务注册中心,消费者不用提供服务
- register-with-eureka: false
- service-url:
- #访问的url
- defaultZone: http://localhost:8002/eureka/
3)在消费者启动类上面加上注解@EnableEurekaClient
- @EnableEurekaClient
4)在配置文件的Bean上加上
- @Bean
- @LoadBalanced
- public RestTemplate getRestTemplate(){
- return new RestTemplate();
- }
五.IRule
什么是IRule
IRule接口代表负载均衡的策略,它的不同的实现类代表不同的策略,它的四种实现类和它的关系如下()
说明一下(idea找Irule的方法:ctrl+n 填入IRule进行查找)
1.RandomRule:表示随机策略,它将从服务清单中随机选择一个服务;
- public class RandomRule extends AbstractLoadBalancerRule {
- public RandomRule() {
- }
- @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
- //传入一个负载均衡器
- public Server choose(ILoadBalancer lb, Object key) {
- if (lb == null) {
- return null;
- } else {
- 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 = this.chooseRandomInt(serverCount);
- //通过这个随机数从列表里获取服务
- server = (Server)upList.get(index);
- if (server == null) {
- //当前线程转为就绪状态,让出cpu
- Thread.yield();
- } else {
- if (server.isAlive()) {
- return server;
- }
- server = null;
- Thread.yield();
- }
- }
- return server;
- }
- }
小结:通过获取到的所有服务的数量,以这个数量为标准获取一个(0,服务数量)的数作为获取服务实例的下标,从而获取到服务实例
2.ClientConfigEnabledRoundRobinRule:ClientConfigEnabledRoundRobinRule并没有实现什么特殊的处理逻辑,但是他的子类可以实现一些高级策略, 当一些本身的策略无法实现某些需求的时候,它也可以做为父类帮助实现某些策略,一般情况下我们都不会使用它;
- public class ClientConfigEnabledRoundRobinRule extends AbstractLoadBalancerRule {
- //使用“4”中的RoundRobinRule策略
- RoundRobinRule roundRobinRule = new RoundRobinRule();
- public ClientConfigEnabledRoundRobinRule() {
- }
- public void initWithNiwsConfig(IClientConfig clientConfig) {
- this.roundRobinRule = new RoundRobinRule();
- }
- public void setLoadBalancer(ILoadBalancer lb) {
- super.setLoadBalancer(lb);
- this.roundRobinRule.setLoadBalancer(lb);
- }
- public Server choose(Object key) {
- if (this.roundRobinRule != null) {
- return this.roundRobinRule.choose(key);
- } else {
- throw new IllegalArgumentException("This class has not been initialized with the RoundRobinRule class");
- }
- }
- }
小结:用来作为父类,子类通过实现它来实现一些高级负载均衡策略
1)ClientConfigEnabledRoundRobinRule的子类BestAvailableRule:从该策略的名字就可以知道,bestAvailable的意思是最好获取的,该策略的作用是获取到最空闲的服务实例;
- public class BestAvailableRule extends ClientConfigEnabledRoundRobinRule {
- //注入负载均衡器,它可以选择服务实例
- private LoadBalancerStats loadBalancerStats;
- public BestAvailableRule() {
- }
- public Server choose(Object key) {
- //假如负载均衡器实例为空,采用它父类的负载均衡机制,也就是轮询机制,因为它的父类采用的就是轮询机制
- if (this.loadBalancerStats == null) {
- return super.choose(key);
- } else {
- //获取所有服务实例并放入列表里
- List<Server> serverList = this.getLoadBalancer().getAllServers();
- //并发量
- int minimalConcurrentConnections = 2147483647;
- long currentTime = System.currentTimeMillis();
- Server chosen = null;
- Iterator var7 = serverList.iterator();
- //遍历服务列表
- while(var7.hasNext()) {
- Server server = (Server)var7.next();
- ServerStats serverStats = this.loadBalancerStats.getSingleServerStat(server);
- //淘汰掉已经负载的服务实例
- if (!serverStats.isCircuitBreakerTripped(currentTime)) {
- //获得当前服务的请求量(并发量)
- int concurrentConnections = serverStats.getActiveRequestsCount(currentTime);
- //找出并发了最小的服务
- if (concurrentConnections < minimalConcurrentConnections) {
- minimalConcurrentConnections = concurrentConnections;
- chosen = server;
- }
- }
- }
- if (chosen == null) {
- return super.choose(key);
- } else {
- return chosen;
- }
- }
- }
- public void setLoadBalancer(ILoadBalancer lb) {
- super.setLoadBalancer(lb);
- if (lb instanceof AbstractLoadBalancer) {
- this.loadBalancerStats = ((AbstractLoadBalancer)lb).getLoadBalancerStats();
- }
- }
- }
小结:ClientConfigEnabledRoundRobinRule子类之一,获取到并发了最少的服务
2)ClientConfigEnabledRoundRobinRule的另一个子类是PredicateBasedRule:通过源码可以看出它是一个抽象类,它的抽象方法getPredicate()返回一个AbstractServerPredicate的实例,然后它的choose方法调用AbstractServerPredicate类的chooseRoundRobinAfterFiltering方法获取具体的Server实例并返回
- public abstract class PredicateBasedRule extends ClientConfigEnabledRoundRobinRule {
- public PredicateBasedRule() {
- }
- //获取AbstractServerPredicate对象
- public abstract AbstractServerPredicate getPredicate();
- public Server choose(Object key) {
- //获取当前策略的负载均衡器
- ILoadBalancer lb = this.getLoadBalancer();
- //通过AbstractServerPredicate的子类过滤掉一部分实例(它实现了Predicate)
- //以轮询的方式从过滤后的服务里选择一个服务
- Optional<Server> server = this.getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
- return server.isPresent() ? (Server)server.get() : null;
- }
- }
再看看它的chooseRoundRobinAfterFiltering()方法是如何实现的
- public Optional<Server> chooseRoundRobinAfterFiltering(List<Server> servers, Object loadBalancerKey) {
- List<Server> eligible = this.getEligibleServers(servers, loadBalancerKey);
- return eligible.size() == 0 ? Optional.absent() : Optional.of(eligible.get(this.incrementAndGetModulo(eligible.size())));
- }
是这样的,先通过this.getEligibleServers(servers, loadBalancerKey)方法获取一部分实例,然后判断这部分实例是否为空,如果不为空则调用eligible.get(this.incrementAndGetModulo(eligible.size())方法从这部分实例里获取一个服务,点进this.getEligibleServers看
- public List<Server> getEligibleServers(List<Server> servers, Object loadBalancerKey) {
- if (loadBalancerKey == null) {
- return ImmutableList.copyOf(Iterables.filter(servers, this.getServerOnlyPredicate()));
- } else {
- List<Server> results = Lists.newArrayList();
- Iterator var4 = servers.iterator();
- while(var4.hasNext()) {
- Server server = (Server)var4.next();
- //条件满足
- if (this.apply(new PredicateKey(loadBalancerKey, server))) {
- //添加到集合里
- results.add(server);
- }
- }
- return results;
- }
- }
getEligibleServers方法是根据this.apply(new PredicateKey(loadBalancerKey, server))进行过滤的,如果满足,就添加到返回的集合中。符合什么条件才可以进行过滤呢?可以发现,apply是用this调用的,this指的是AbstractServerPredicate(它的类对象),但是,该类是个抽象类,该实例是不存在的,需要子类去实现,它的子类在这里暂时不是看了,以后有空再深入学习下,它的子类如下,实现哪个子类,就用什么 方式过滤。
再回到chooseRoundRobinAfterFiltering()方法,刚刚说完它通过 getEligibleServers方法过滤并获取到一部分实例,然后再通过this.incrementAndGetModulo(eligible.size())方法从这部分实例里选择一个实例返回,该方法的意思是直接返回下一个整数(索引值),通过该索引值从返回的实例列表中取得Server实例。
- private int incrementAndGetModulo(int modulo) {
- //当前下标
- int current;
- //下一个下标
- int next;
- do {
- //获得当前下标值
- current = this.nextIndex.get();
- next = (current + 1) % modulo;
- } while(!this.nextIndex.compareAndSet(current, next) || current >= modulo);
- return current;
- }
源码撸明白了,再来理一下chooseRoundRobinAfterFiltering()的思路:先通过getEligibleServers()方法获得一部分服务实例,再从这部分服务实例里拿到当前服务实例的下一个服务对象使用。
小结:通过AbstractServerPredicate的chooseRoundRobinAfterFiltering方法进行过滤,获取备选的服务实例清单,然后用线性轮询选择一个实例,是一个抽象类,过滤策略在AbstractServerPredicate的子类中具体实现
3.RetryRule:是对选定的负载均衡策略加上重试机制,即在一个配置好的时间段内(默认500ms),当选择实例不成功,则一直尝试使用subRule的方式选择一个可用的实例,在调用时间到达阀值的时候还没找到可用服务,则返回空,如果没有配置负载策略,默认轮询(即“4”中的轮询);
先贴上它的源码
- public class RetryRule extends AbstractLoadBalancerRule {
- //从这可以看出,默认使用轮询机制
- IRule subRule = new RoundRobinRule();
- //500秒的阀值
- long maxRetryMillis = 500L;
- //无参构造函数
- public RetryRule() {
- }
- //使用轮询机制
- public RetryRule(IRule subRule) {
- this.subRule = (IRule)(subRule != null ? subRule : new RoundRobinRule());
- }
- public RetryRule(IRule subRule, long maxRetryMillis) {
- this.subRule = (IRule)(subRule != null ? subRule : new RoundRobinRule());
- this.maxRetryMillis = maxRetryMillis > 0L ? maxRetryMillis : 500L;
- }
- public void setRule(IRule subRule) {
- this.subRule = (IRule)(subRule != null ? subRule : new RoundRobinRule());
- }
- public IRule getRule() {
- return this.subRule;
- }
- //设置最大耗时时间(阀值),最多重试多久
- public void setMaxRetryMillis(long maxRetryMillis) {
- if (maxRetryMillis > 0L) {
- this.maxRetryMillis = maxRetryMillis;
- } else {
- this.maxRetryMillis = 500L;
- }
- }
- //获取重试的时间
- public long getMaxRetryMillis() {
- return this.maxRetryMillis;
- }
- //设置负载均衡器,用以获取服务
- public void setLoadBalancer(ILoadBalancer lb) {
- super.setLoadBalancer(lb);
- this.subRule.setLoadBalancer(lb);
- }
- //通过负载均衡器选择服务
- public Server choose(ILoadBalancer lb, Object key) {
- long requestTime = System.currentTimeMillis();
- //当前时间+阀值 = 截止时间
- long deadline = requestTime + this.maxRetryMillis;
- Server answer = null;
- answer = this.subRule.choose(key);
- //获取到服务直接返回
- if ((answer == null || !answer.isAlive()) && System.currentTimeMillis() < deadline) {
- InterruptTask task = new InterruptTask(deadline - System.currentTimeMillis());
- //获取不到服务的情况下反复获取
- while(!Thread.interrupted()) {
- answer = this.subRule.choose(key);
- if (answer != null && answer.isAlive() || System.currentTimeMillis() >= deadline) {
- break;
- }
- Thread.yield();
- }
- task.cancel();
- }
- return answer != null && answer.isAlive() ? answer : null;
- }
- public Server choose(Object key) {
- return this.choose(this.getLoadBalancer(), key);
- }
- public void initWithNiwsConfig(IClientConfig clientConfig) {
- }
- }
小结:采用RoundRobinRule的选择机制,进行反复尝试,当花费时间超过设置的阈值maxRetryMills时,就返回null
4.RoundRobinRule:轮询策略,它会从服务清单中按照轮询的方式依次选择每个服务实例,它的工作原理是:直接获取下一个可用实例,如果超过十次没有获取到可用的服务实例,则返回空且报出异常信息;
- public class RoundRobinRule extends AbstractLoadBalancerRule {
- private AtomicInteger nextServerCyclicCounter;
- private static final boolean AVAILABLE_ONLY_SERVERS = true;
- private static final boolean ALL_SERVERS = false;
- private static Logger log = LoggerFactory.getLogger(RoundRobinRule.class);
- public RoundRobinRule() {
- this.nextServerCyclicCounter = new AtomicInteger(0);
- }
- public RoundRobinRule(ILoadBalancer lb) {
- this();
- this.setLoadBalancer(lb);
- }
- public Server choose(ILoadBalancer lb, Object key) {
- if (lb == null) {
- log.warn("no load balancer");
- return null;
- } else {
- Server server = null;
- int count = 0;
- while(true) {
- //选择十次,十次都没选到可用服务就返回空
- if (server == null && count++ < 10) {
- List<Server> reachableServers = lb.getReachableServers();
- List<Server> allServers = lb.getAllServers();
- int upCount = reachableServers.size();
- int serverCount = allServers.size();
- if (upCount != 0 && serverCount != 0) {
- int nextServerIndex = this.incrementAndGetModulo(serverCount);
- server = (Server)allServers.get(nextServerIndex);
- if (server == null) {
- Thread.yield();
- } else {
- if (server.isAlive() && server.isReadyToServe()) {
- return server;
- }
- server = null;
- }
- continue;
- }
- log.warn("No up servers available from load balancer: " + lb);
- return null;
- }
- if (count >= 10) {
- log.warn("No available alive servers after 10 tries from load balancer: " + lb);
- }
- return server;
- }
- }
- }
- //递增的形式实现轮询
- private int incrementAndGetModulo(int modulo) {
- int current;
- int next;
- do {
- current = this.nextServerCyclicCounter.get();
- next = (current + 1) % modulo;
- } while(!this.nextServerCyclicCounter.compareAndSet(current, next));
- return next;
- }
- public Server choose(Object key) {
- return this.choose(this.getLoadBalancer(), key);
- }
- public void initWithNiwsConfig(IClientConfig clientConfig) {
- }
- }
小结:采用线性轮询机制循环依次选择每个服务实例,直到选择到一个不为空的服务实例或循环次数达到10次
它有个子类WeightedResponseTimeRule,WeightedResponseTimeRule是对RoundRobinRule的优化。WeightedResponseTimeRule在其父类的基础上,增加了定时任务这个功能,通过启动一个定时任务来计算每个服务的权重,然后遍历服务列表选择服务实例,从而达到更加优秀的分配效果。我们这里把这个类分为三部分:定时任务,计算权值,选择服务
1)定时任务
- //定时任务
- void initialize(ILoadBalancer lb) {
- if (this.serverWeightTimer != null) {
- this.serverWeightTimer.cancel();
- }
- this.serverWeightTimer = new Timer("NFLoadBalancer-serverWeightTimer-" + this.name, true);
- //开启一个任务,每30秒执行一次
- this.serverWeightTimer.schedule(new WeightedResponseTimeRule.DynamicServerWeightTask(), 0L, (long)this.serverWeightTaskTimerInterval);
- WeightedResponseTimeRule.ServerWeight sw = new WeightedResponseTimeRule.ServerWeight();
- sw.maintainWeights();
- Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
- public void run() {
- WeightedResponseTimeRule.logger.info("Stopping NFLoadBalancer-serverWeightTimer-" + WeightedResponseTimeRule.this.name);
- WeightedResponseTimeRule.this.serverWeightTimer.cancel();
- }
- }));
- }
DynamicServerWeightTask()任务如下:
- class DynamicServerWeightTask extends TimerTask {
- DynamicServerWeightTask() {
- }
- public void run() {
- WeightedResponseTimeRule.ServerWeight serverWeight = WeightedResponseTimeRule.this.new ServerWeight();
- try {
- //计算权重
- serverWeight.maintainWeights();
- } catch (Exception var3) {
- WeightedResponseTimeRule.logger.error("Error running DynamicServerWeightTask for {}", WeightedResponseTimeRule.this.name, var3);
- }
- }
- }
小结:调用initialize方法开启定时任务,再在任务里计算服务的权重
2)计算权重:第一步,先算出所有实例的响应时间;第二步,再根据所有实例响应时间,算出每个实例的权重
- //用来存储权重
- private volatile List<Double> accumulatedWeights = new ArrayList();
- //内部类
- class ServerWeight {
- ServerWeight() {
- }
- //该方法用于计算权重
- public void maintainWeights() {
- //获取负载均衡器
- ILoadBalancer lb = WeightedResponseTimeRule.this.getLoadBalancer();
- if (lb != null) {
- if (WeightedResponseTimeRule.this.serverWeightAssignmentInProgress.compareAndSet(false, true)) {
- try {
- WeightedResponseTimeRule.logger.info("Weight adjusting job started");
- AbstractLoadBalancer nlb = (AbstractLoadBalancer)lb;
- //获得每个服务实例的信息
- LoadBalancerStats stats = nlb.getLoadBalancerStats();
- if (stats != null) {
- //实例的响应时间
- double totalResponseTime = 0.0D;
- ServerStats ss;
- //累加所有实例的响应时间
- for(Iterator var6 = nlb.getAllServers().iterator(); var6.hasNext(); totalResponseTime += ss.getResponseTimeAvg()) {
- Server server = (Server)var6.next();
- ss = stats.getSingleServerStat(server);
- }
- Double weightSoFar = 0.0D;
- List<Double> finalWeights = new ArrayList();
- Iterator var20 = nlb.getAllServers().iterator();
- //计算负载均衡器所有服务的权重,公式是weightSoFar = weightSoFar + weight-实例平均响应时间
- while(var20.hasNext()) {
- Server serverx = (Server)var20.next();
- ServerStats ssx = stats.getSingleServerStat(serverx);
- double weight = totalResponseTime - ssx.getResponseTimeAvg();
- weightSoFar = weightSoFar + weight;
- finalWeights.add(weightSoFar);
- }
- WeightedResponseTimeRule.this.setWeights(finalWeights);
- return;
- }
- } catch (Exception var16) {
- WeightedResponseTimeRule.logger.error("Error calculating server weights", var16);
- return;
- } finally {
- WeightedResponseTimeRule.this.serverWeightAssignmentInProgress.set(false);
- }
- }
- }
- }
- }
3)选择服务
- @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
- public Server choose(ILoadBalancer lb, Object key) {
- if (lb == null) {
- return null;
- } else {
- Server server = null;
- while(server == null) {
- List<Double> currentWeights = this.accumulatedWeights;
- if (Thread.interrupted()) {
- return null;
- }
- List<Server> allList = lb.getAllServers();
- int serverCount = allList.size();
- if (serverCount == 0) {
- return null;
- }
- int serverIndex = 0;
- double maxTotalWeight = currentWeights.size() == 0 ? 0.0D : (Double)currentWeights.get(currentWeights.size() - 1);
- if (maxTotalWeight >= 0.001D && serverCount == currentWeights.size()) {
- //生产0到最大权重值的随机数
- double randomWeight = this.random.nextDouble() * maxTotalWeight;
- int n = 0;
- //循环权重区间
- for(Iterator var13 = currentWeights.iterator(); var13.hasNext(); ++n) {
- //获取到循环的数
- Double d = (Double)var13.next();
- //假如随机数在这个区间内,就拿该索引d服务列表获取对应的实例
- if (d >= randomWeight) {
- serverIndex = n;
- break;
- }
- }
- server = (Server)allList.get(serverIndex);
- } else {
- server = super.choose(this.getLoadBalancer(), key);
- if (server == null) {
- return server;
- }
- }
- if (server == null) {
- Thread.yield();
- } else {
- if (server.isAlive()) {
- return server;
- }
- server = null;
- }
- }
- return server;
- }
- }
小结:首先生成了一个[0,最大权重值) 区间内的随机数,然后遍历权重列表,假如当前随机数在这个区间内,就通过该下标获得对应的服务。
以上就是详解SpringCloud的负载均衡的详细内容,更多关于SpringCloud 负载均衡的资料请关注服务器之家其它相关文章!
原文链接:https://www.cnblogs.com/fengrongriup/p/14505755.html