Ribbon自定义负载均衡算法

Ribbon是什么？

Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。

负载均衡

负载均衡（Load Balance），意思是将负载（工作任务，访问请求）进行平衡、分摊到多个操作单元（服务器，组件）上进行执行。是解决高性能，单点故障（高可用），扩展性（水平伸缩）的终极解决方案。

集中式LB和进程内LB

而负载均衡又分为两类，集中式负载均衡和进程内负载均衡，什么是集中式负载均衡和进程内负载均衡？

集中式负载均衡
在服务的消费方和提供方之间使用独立的负载均衡设施（可以是硬件，如F5,也可以是软件，如nginx）,由该设施负责吧访问请求通过某中策略转发至服务的提供方

进程内负载均衡
将负载均衡逻辑集成到消费方，消费方从服务注册中心获知那些地址可用，然后自己再从这些地址中选择一个合适的服务器，例如ribbon,ribbon只是一个类库，集成在消费方进程，消费方通过它来获取到服务提供方的地址

Riboon怎么做到负载均衡的？

先看看Ribbon的原理图
从下面的原理图可以看到服务提供者去注册服务到注册中心Eureka去，而服务消费者通过Ribbon去服务注册中心获取查询这些可以的服务列表，然后根据要调用的那个服务进行负载均衡请求

Ribbon自带的负载均衡算法

Ribbon自带了7中负载均衡算法

1、RoundRobinRule
默认的，轮询规则，也是很多高级规则中退避的一种策略

2、 AvailabilityFilteringRule
会过滤掉打开熔断的服务或者是高并发连接数量的服务

3、 WeightedResponseTimeRule
通过服务的平均响应时间，给每一个服务一个权重，响应时间越长，权重越小，开始统计信息不足，应用轮询策略

4、 RetryRule
先按照轮询策略，如果请求服务失败，会在指定时间内进行重试

5、 BestAvailableRule
先过滤掉断路器的服务，然后选择一个并发量最小的

6、 RandomRule
随机获取一个服务

7、ZoneAvoidanceRule
根据性能和可用性来选择。

Ribbon默认是使用轮询的算法，怎么修改？

第一步
添加自定义类，但是要注意存放的位置这个自定义的类不能放在@ComponentScan所扫描的当前包以及子包下，否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享，也就是我们达不到特殊化指定的目的了，也就是说不能放在与主启动类同包及子包下

第二步
在客户端添加一个controller，去调用服务

@GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPayment(@PathVariable("id")Long id){
     
        return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
    }

第三步
将三个服务添加注册到服务中心

调用消费者模块的/consumer/payment/get/{id}，成功出现随机的

如果我们想用自己写的负载均衡算法怎么办？

先看看ribbon的负载均衡算法是什么结构？怎么写的?

先看看这个接口，这个接口是Ribbon中自己的负载均衡算法所实现的

看一下他的实现类，这个抽象类实现了IRule,抽象类实现接口是为了让子类更容易的去实现这个接口，这个抽象类只对IRule接口中的setLoadBalancer和getLoadBalancer进行了实现，把获取到的值进行赋值保存，方便的子类的使用，这两个方法可以看作是获取服务中心的服务信息

再来看看Ribbon的自己的负载均衡算法是怎么实现的?他实现了上面说的那个抽象类

首先会先调用这个choose，这个choose调用了父类AbstractLoadBalancerRule的getLoadBalancer，上面说过这个可以看作是获取服务中心的服务信息，然后调用了choose的重载方法

使用lb去获取存活(活跃)的服务和获取所有服务

获取服务数量的长度，然后调用chooseRandomInt（），去获取一个服务数量内的随机的下标，然后调用存放存活的服务的list通过下标去获取一个存活的服务

然后对获取的这个服务判断是否是存活状态，如果是存活状态就返回这个服务给调用者调用，如果不是存活的话 就就执行Thread.yield（）线程让步，然后等再次循环拿下一个服务

Thread.yield( )解释

Java线程中的Thread.yield( )方法，译为线程让步。顾名思义，就是说当一个线程使用了这个方法之后，它就会把自己CPU执行的时间让掉，
让自己或者其它的线程运行，注意是让自己或者其他线程运行，并不是单纯的让给其他线程。
​ yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保
证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！

开始自定义负载均衡

从上面的源码分析可以看到我们要自定义负载均衡算法需要继承IRule的抽象实现类AbstractLoadBalancerRule，所以我们也可以写一个类去实现他，然后在 Server choose(ILoadBalancer lb, Object key) 里面设置规则

我们就先自定义一个轮询的，不使用ribbon自带的

编写一个类继承AbstractLoadBalancerRule，然后模仿ribbon自带的，创建一个choose的重载方法，注意：记得加上**@Component**注解，否则SpringBoot不会扫描到

@Component
public class MyRoundRobinRule extends AbstractLoadBalancerRule {
     
    //定义一个原子类，以保证原子性
    private AtomicInteger atomicInteger =new AtomicInteger(0);

    @Override
    public void initWithNiwsConfig(IClientConfig iClientConfig) {
     
    }

    public Server choose(ILoadBalancer lb, Object key) {
     
        if (lb == null){
     
            return null;
        }
        //用于统计获取次数，当达到一定数量就不再去尝试
        int count = 0;
        Server server = null;
        //当服务还没获取到，并且尝试没有超过8次
        while (server == null && count++ < 8){
     
            //获取服务
            List<Server> allServers = lb.getAllServers();
            List<Server> reachableServers = lb.getReachableServers();
            int allServersSize = allServers.size();
            int reachableServersSize = reachableServers.size();
            //如果获取的服务list都为0就返回null
            if(allServersSize == 0 || reachableServersSize == 0){
     
                return  null;
            }
            //获取服务下标
            int next = getServerIndex(allServersSize);

            //获取服务
            server = reachableServers.get(next);

            //如果服务为空直接跳过下面的
            if (server == null){
     
                continue;
            }

            //如果获取到的这个服务是活着的就返回
            if (server.isAlive()){
     
                return server;
            }

            //如果获取到的服务不是空，但是不是存活状态，需要重新获取
            server=null;
        }

        //最后这里可能会返回null
        return  server;
    }

    //获取服务下标，为了保证原子性，使用了CAS
    public int getServerIndex(int allServersSize){
     
        //自旋锁
        for (;;) {
     
            //获取当前值
            int current = this.atomicInteger.get();
            //设置期望值
            int next = (current + 1) % allServersSize;
            //调用Native方法compareAndSet，执行CAS操作
            if (this.atomicInteger.compareAndSet(current, next))
                //成功后才会返回期望值，否则无线循环
                return next;
        }
    }
    @Override
    public Server choose(Object key) {
     

        return choose(getLoadBalancer(),key);
    }
}

在主启动类上添加
@RibbonClient(name = “CLOUD-PAYMENT-SERVICE” ,configuration = MyRoundRobinRule.class)
configuration 指定自己的负载均衡策略

在RestTemplate加@LoadBalanced

启动测试，成功出现轮询！