SpringCloud系列--Ribbon(3)负载均衡算法

前面两节介绍了Ribbon的（1）介绍和使用和（2）核心组件IRule，这节介绍Ribbon的负载均衡算法，以及自己写一个轮询算法。

1、原理

负载均衡算法：Rest接口第几次请求数 % 服务器集群总数量 = 实际调用服务器位置下标，每次服务重启动后Rest接口计数从1开始。

List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");

如List[0] instances = 127.0.0.1:8002
  List[1] instances = 127.0.0.1:8001
8001+8002组合成为集群，它们共计2台机器，集群总数为2，按照轮询算法原理：
当总请求数为1时：1%2 = 1对应下标位置为1，则获得服务地址为127.0.0.1：8001
当总请求数为2时：2%2 = 0对应下标位置为0，则获得服务地址为127.0.0.1：8002
当总请求数为3时：3%2 = 1对应下标位置为1，则获得服务地址为127.0.0.1：8001
当总请求数为4时：4%2 = 0对应下标位置为0，则获得服务地址为127.0.0.1：8002
如此类推......

2、源码分析

SpringCloud系列–Ribbon(2)核心组件IRule中介绍到IRule接口有个choose方法 - - choose(Object key)：根据某种算法从lb的负载列表中获得key、从而选择一个有效的服务。
如下图所示，IRule有实现类RoundRobinRule(轮循算法)，这里以RoundRobinRule为例叙述Ribbon算法实现:

public class RoundRobinRule extends AbstractLoadBalancerRule {

    //原子整形变量，初始值为0
    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() {
        nextServerCyclicCounter = new AtomicInteger(0);
    }

    public RoundRobinRule(ILoadBalancer lb) {
        this();
        setLoadBalancer(lb);
    }

    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) {
        	//  Only the servers that are up and reachable.
        	// 活着的服务机器
            List<Server> reachableServers = lb.getReachableServers();
            // All known servers, both reachable and unreachable.
            // 所有服务端
            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);
            server = allServers.get(nextServerIndex);

            if (server == null) {
                /* Transient. */
                Thread.yield();
                continue;
            }

            if (server.isAlive() && (server.isReadyToServe())) {
                return (server);
            }

            // Next.
            server = null;
        }

        if (count >= 10) {
            log.warn("No available alive servers after 10 tries from load balancer: "
                    + lb);
        }
        return server;
    }

    /**
     * Inspired by the implementation of {@link AtomicInteger#incrementAndGet()}.
     *
     * @param modulo The modulo to bound the value of the counter.
     * @return The next value.
     */
    private int incrementAndGetModulo(int modulo) {
        for (;;) {
            int current = nextServerCyclicCounter.get();
            int next = (current + 1) % modulo;
            if (nextServerCyclicCounter.compareAndSet(current, next))
                return next;
        }
    }

    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

RoundRobinRule继承AbstractLoadBalancerRule，调用choose(Object)时，调用内部方法 choose(ILoadBalancer lb, Object key)。
其中：

• 原子整形变量AtomicInteger nextServerCyclicCounter初始默认值为0。
• int serverCount = allServers.size()就是上述负载均衡算法中的服务器集群总数量。
• incrementAndGetModulo方法，就是增加计数取余得到访问的server的index，用CAS来实现线程安全。
• 得到服务Server后，判断是否是alive和ReadyToServe，则返回；如果循坏了10次还没有找到，则log打印warn日志提示。

3、写一个轮询算法

接下来我们自己写一个本地负载均衡器。

3.1、LoadBalancer接口

public interface LoadBalancer
{
    ServiceInstance instances(List<ServiceInstance> serviceInstances);
}

3.2、接口的实现类

@Component
public class MyLB implements LoadBalancer
{

    private AtomicInteger atomicInteger = new AtomicInteger(0);

    public final int getAndIncrement()
    {
        int current;
        int next;

        do {
            current = this.atomicInteger.get();
            next = current >= 2147483647 ? 0 : current + 1;
        }while(!this.atomicInteger.compareAndSet(current,next));
        System.out.println("*****第几次访问，次数next: "+next);
        return next;
    }

    //负载均衡算法：rest接口第几次请求数 % 服务器集群总数量 = 实际调用服务器位置下标  ，每次服务重启动后rest接口计数从1开始。
    @Override
    public ServiceInstance instances(List<ServiceInstance> serviceInstances)
    {
        int index = getAndIncrement() % serviceInstances.size();

        return serviceInstances.get(index);
    }
}

3.3、引入自定义的负载均衡器

服务消费端controller代码如下：

@RestController
@Slf4j
public class OrderController {

    public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";

    @Resource
    private RestTemplate restTemplate;

	//注入自定义的LoadBalancer
    @Resource
    private LoadBalancer loadBalancer;
    
    @Resource
    private DiscoveryClient discoveryClient;

    @GetMapping(value = "/consumer/payment/lb")
    public String getPaymentLB()
    {
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");

        if(instances == null || instances.size() <= 0)
        {
            return null;
        }

        ServiceInstance serviceInstance = loadBalancer.instances(instances);
        URI uri = serviceInstance.getUri();

        return restTemplate.getForObject(uri+"/payment/lb",String.class);

    }
}

3.4、主启动类

@SpringBootApplication
@EnableEurekaClient
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class, args);
    }
}

3.5、application.yml

server:
  port: 80

spring:
  application:
    name: cloud-order-service

eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
      #单机
      #defaultZone: http://localhost:7001/eureka
      # 集群
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版

3.6、restTemplate

@Configuration
public class ApplicationContextConfig {

    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

此时启动服务即可测试自定义的轮询负载均衡器。