springCloud(九)

上一篇学习到了LoadBalance的其中一个关键组成部分是负载均衡策略，其最基础的接口是IRule。

public interface IRule{    /*     * choose one alive server from lb.allServers or     * lb.upServers according to key     *      * @return choosen Server object. NULL is returned if none     *  server is available      */    public Server choose(Object key);        public void setLoadBalancer(ILoadBalancer lb);        public ILoadBalancer getLoadBalancer();    }

我们可以看到Ribbon已经实现接口的：

我们挨个看一遍，

首先是AvailabilityFilteringRule，他会根据把特殊情况的server排除，

特殊情况包括  1：in circuit breaker tripped state due to consecutive connection or read failures

2： have active connections that exceeds a configurable limit 

        一个是处于短路状态，一个是超过了最大连接数。

     过滤逻辑在AvailabilityPredicate中，

 @Override    public boolean apply(@Nullable PredicateKey input) {        LoadBalancerStats stats = getLBStats();        if (stats == null) {            return true;        }        return !shouldSkipServer(stats.getSingleServerStat(input.getServer()));    }            private boolean shouldSkipServer(ServerStats stats) {                if ((CIRCUIT_BREAKER_FILTERING.get() && stats.isCircuitBreakerTripped())                 || stats.getActiveRequestsCount() >= activeConnectionsLimit.get()) {            return true;        }        return false;    }

接下来是BestAvailableRule，首先是过滤掉短路状态的服务，在可用服务中选择并发数最小的。

 public Server choose(Object key) {        if (loadBalancerStats == null) {            return super.choose(key);        }        List<Server> serverList = getLoadBalancer().getAllServers();        int minimalConcurrentConnections = Integer.MAX_VALUE;        long currentTime = System.currentTimeMillis();        Server chosen = null;        for (Server server: serverList) {            ServerStats serverStats = 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;        }    }

我们可以看到，比较简单，遍历一遍所有的server，去除掉短路状态的服务后，选择出并发量最小的。

接下来是RandomRule，随机选择一个服务。

接下来是RetryRule，在已经有的规则上增加重试机制，默认情况下重试机制的规则是RoundRobinRule。

接下来是RoundRobinRule，轮训的方式选择server，其主要是保存了一个 AtomicInteger nextServerCyclicCounter;利用CAS保证线程安全。

其计算index的算法如下：

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

其中modulo就是服务的总数量。

最后一个是WeightedResponseTimeRule，动态的利用response时间计算全职。

doc中的例子非常好：

* The basic idea for weighted round robin has been obtained from JCS * The implementation for choosing the endpoint from the list of endpoints * is as follows:Let's assume 4 endpoints:A(wt=10), B(wt=30), C(wt=40),  * D(wt=20).  * <p> * Using the Random API, generate a random number between 1 and10+30+40+20. * Let's assume that the above list is randomized. Based on the weights, we * have intervals as follows: * <p> * 1-----10 (A's weight) * <br> * 11----40 (A's weight + B's weight) * <br> * 41----80 (A's weight + B's weight + C's weight) * <br> * 81----100(A's weight + B's weight + C's weight + C's weight) * <p> * Here's the psuedo code for deciding where to send the request: * <p> * if (random_number between 1 & 10) {send request to A;} * <br> * else if (random_number between 11 & 40) {send request to B;} * <br> * else if (random_number between 41 & 80) {send request to C;} * <br> * else if (random_number between 81 & 100) {send request to D;} * <p> * When there is not enough statistics gathered for the servers, this rule * will fall back to use {@link RoundRobinRule}.

其实就是把总体看做一个圆盘，权重越大所占的面积越大，随机数落在其区域的概率越大。当统计稿率不足时，使用RoundRobinRule。

 // holds the accumulated weight from index 0 to current index    // for example, element at index 2 holds the sum of weight of servers from 0 to 2    private volatile List<Double> accumulatedWeights = new ArrayList<Double>();

其中把累加概率保存到了一个列表里，每次计算一个随机数，第一个大于随机数的位置，就是待选泽的server位置。

今天先到这里，接下来继续学习