Ribbon几种负载均衡策略代码解析

一、RandomRule
二、RoundRobinRule
三、RetryRule

我们都知道SpringCloud中的本地负载均衡组件Ribbon，Feign中集成了Ribbon和Hystrix，使得我们使用Ribbon变得更加方便。

Ribbon中的负载均衡策略都继承自AbstractLoadBalancerRule这个抽象类。

AbstractLoadBalancerRule 实现了 IRule 和 IClientConfigAware 这两个接口。

1) IClientConfigAware这个很好理解，看它的方法就知道，用于加载配置信息的。

2) IRule中的choose()方法是核心方法，具体负载均衡策略核心逻辑就在这个方法中，它返回的是是一个Server，代表请求将要调用的服务。IRule还将ILoadBanlancer这个类复合进我们的负载均衡策略类中，因为到时候需要使用ILoadBanlancer中的获取服务列表等操作。

回到顶部

一、RandomRule

最简单的策略，从代码来看分为以下步骤：

1. Random rand = new Random(); //使用java自带的随机数生成类

2. List<Server> upList = lb.getReachableServers();// 可用服务列表

List<Server> allList = lb.getAllServers();//所有服务列表

3. in serverCount = allList.size()

2. int index = this.rand.nextInt(serverCount); //随机数范围是0到serverCount（不包括serverCount）

3. server = (Server)upList.get(index); //上面范围是以所有服务的列表大小算，但是取值却从upList取，为啥，懂的评论区留言提点下我

部分代码截图：

回到顶部

二、RoundRobinRule

轮询是Ribbon默认的负载均衡策略，逻辑也比较简单，定义一个AtomicInteger初始值为0（不断调用choose时，这个值是不停增长的）每次用它加1后对serverCount取余，获取到的int值用来从allServers列表中get一个server，同时使用CAS使AtomicInteger的值加1。

获取到的server需要判断是否可用，可用则返回，不可用继续AtomicInteger取余那个过程。

以上轮询最多只会重试10次（通过while循环），如果还获取不到可用server则打印warn日志，直接返回null

看下主要步骤的代码：

int nextServerIndex = this.incrementAndGetModulo(serverCount);
server = (Server)allServers.get(nextServerIndex);

这个是取余方法：

private int incrementAndGetModulo(int modulo) {
        int current;
        int next;
        do {
            current = this.nextServerCyclicCounter.get(); // 这就是刚才我说的AtomicInteger变量，这是一个类成员变量
            next = (current + 1) % modulo;
        } while(!this.nextServerCyclicCounter.compareAndSet(current, next));

        return next;
}

回到顶部

三、RetryRule

首先我们从开头就可以看到，RetryRule是基于RoundRobinRule的：

接下来分析他的choose方法，看看他和普通轮询有啥不同：

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;
    }