Ribbon源码轮询负载均衡算法你知道吗?

最新推荐文章于 2024-09-15 15:37:22 发布

原创最新推荐文章于 2024-09-15 15:37:22 发布 · 311 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#ribbon #java

本文详细解析了Ribbon的ZoneAwareLoadBalancer类中chooseServer方法的工作原理，包括如何调用父类方法、使用IRule组件进行负载均衡，以及核心的轮询算法实现过程。

1.首先我们需要找到负载均衡算法的源头在哪里,那么就必须要先找到他的入口ZoneAwareLoadBalancer里面的chooseServer(Object key)

 @Override
    public Server chooseServer(Object key) {
        if (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) {
            logger.debug("Zone aware logic disabled or there is only one zone");
            return super.chooseServer(key);
        }

2.此时会调用父类的chooseServer(key) 方法

 /*
     * Get the alive server dedicated to key
     * 
     * @return the dedicated server
     */
    public Server chooseServer(Object key) {
        if (counter == null) {
            counter = createCounter();
        }
        counter.increment();
        if (rule == null) {
            return null;
        } else {
            try {
		//主要是使用 IRule,Ribbon核心组件进行负载,默认轮询负载
                return rule.choose(key);
            } catch (Exception e) {
                logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", name, key, e);
                return null;
            }
        }
    }

调用Ribbon的负载均衡组件IRule的默认轮询进行负载,rule.choose(key)
3.然后会调用PredicateBasedRule类下的choose(Object key)方法

 @Override
    public Server choose(Object key) {
        ILoadBalancer lb = getLoadBalancer();
        Optional<Server> server = getPredicate().chooseRoundRobinAfterFiltering(lb.getAllServers(), key);
        if (server.isPresent()) {
            return server.get();
        } else {
            return null;
        }       
    }

上面代码会调用chooseRoundRobinAfterFiltering 过滤器进行调用负载
然后调用AbstractServerPredicatel类下的过滤器chooseRoundRobinAfterFiltering

public Optional<Server> chooseRoundRobinAfterFiltering(List<Server> servers, Object loadBalancerKey) {
        List<Server> eligible = getEligibleServers(servers, loadBalancerKey);
        if (eligible.size() == 0) {
            return Optional.absent();
        }
        return Optional.of(eligible.get(incrementAndGetModulo(eligible.size())));
    }

以上代码eligible主要作用是获取需要负载的Server的数量,加入有两台机器需要进行负载则需要负载数量为2,传入到incrementAndGetModulo(int modulo)中的算法进行负载,那么进入到最终的算法原型代码

4.负载均衡算法代码解析.

private int incrementAndGetModulo(int modulo) {
for (;;) {
int current = nextIndex.get();
int next = (current + 1) % modulo;
if (nextIndex.compareAndSet(current, next) && current < modulo)
return current;
}
}

针对如上代码我们通过进行推演的模式进行解析轮询算法的秘密
假设需要负载的机器就只有两台.
那么此时: modulo = 2
进入for循环
nextIndex 是一个AtomicInter 原子类默认为 0
current = 0
next = (0 + 1) % 2 = 1 (1取模2是等于1)
判断条件 nextIndex.compareAndSet(current,next) 这里用到的其实是乐观锁,基于CAS自旋锁进行比较替换,当current和next不一样的时候采取将current替换成next.
nextIndex 进行比较替换不一样则替换一样则保留
current =0 是旧值 next = 1 是新值两者不一样所以 nextIndex 替换成1 并且 current = 0 小于modulo = 2
所以正常返回 0

假设第二次进来
current = nextIndex.get() = 1
next = 1 +1 %2 = 0
nextIndex 比较替换 1 和 0 不一样进行替换成 0 并且 1 < 2
所以正常返回 1

第三次进来又一次返回原点.所以会一直轮询选择不同的机器进行负载,这就是轮询负载均衡的算法实现了.