[享学Netflix] 五十一、Ribbon的LoadBalancer五大组件之：IRule（一）轮询和加权轮询

public interface IRule {

	// 最为重要的一个方法：从lb.allServers/lb.upServers根据key找到一台Server
	// 若没找到返回null
	public Server choose(Object key);

	public void setLoadBalancer(ILoadBalancer lb);
	public ILoadBalancer getLoadBalancer();
}

public abstract class AbstractLoadBalancerRule implements IRule, IClientConfigAware {

    private ILoadBalancer lb;   
    
    @Override
    public void setLoadBalancer(ILoadBalancer lb){
        this.lb = lb;
    }
    @Override
    public ILoadBalancer getLoadBalancer(){
        return lb;
    }      
}

public class RoundRobinRule extends AbstractLoadBalancerRule {
    private AtomicInteger nextServerCyclicCounter;
    private static final boolean AVAILABLE_ONLY_SERVERS = true;
    private static final boolean ALL_SERVERS = false;
}

RoundRobinRule：

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

RoundRobinRule：

	// 注意：它仅是个public方法，并非接口方法
	// 另外，它轮询的是lb里的allServers，而并非只是up的哦~~~~
	public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            log.warn("no load balancer");
            return null;
        }

		Server server = null;
		// 一次choose中最多轮询10次，如果还没有找到可用的，那就放弃 避免你有100台机器，一直轮询下去
		int count = 0; 
		while (server == null && count++ < 10) {
			// 说明：up的机器仅仅只是做一个数量的判断，并不参与整整的轮询
			// 真正轮询的是allServers，这点特别注意
            List<Server> reachableServers = lb.getReachableServers();
            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);

			// 若选出的这个server是活的并且可以服务了，那就return
			// 否则，继续下一轮的循环获取
			// 所以，，，为毛不直接轮询upServers呢？？？这个后文会给出解释
            if (server.isAlive() && (server.isReadyToServe())) {
                return (server);
            }
            server = null;
		}
		
		// 10次都还没找到一台可用的，那就不用再找了。返回null
        if (count >= 10) {
            log.warn("No available alive servers after 10 tries from load balancer: "  + lb);
        }
        return server;
	}

RoundRobinRule：

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

public class WeightedResponseTimeRule extends RoundRobinRule {
	
	public static final IClientConfigKey<Integer> WEIGHT_TASK_TIMER_INTERVAL_CONFIG_KEY = CommonClientConfigKey.valueOf("ServerWeightTaskTimerInterval");
	public static final int DEFAULT_TIMER_INTERVAL = 30 * 1000;

	private int serverWeightTaskTimerInterval = DEFAULT_TIMER_INTERVAL;
	private volatile List<Double> accumulatedWeights = new ArrayList<Double>();
	private final Random random = new Random();
	protected Timer serverWeightTimer = null;
	protected AtomicBoolean serverWeightAssignmentInProgress = new AtomicBoolean(false);
	String name = "unknown";

}

WeightedResponseTimeRule：

    @Override
    public Server choose(ILoadBalancer lb, Object key) {
    
    	Server server = null;
    	// 循环内找出一台Server
    	while (server == null) {
    		// 获取当前引用，以防它被其他线程更改
    		List<Double> currentWeights = accumulatedWeights;
    		// 轮询的也是所有的Server
    		List<Server> allList = lb.getAllServers();
    		int serverCount = allList.size();
            if (serverCount == 0) {
                return null;
            }

			// 列表中的最后一个是所有权值的和
			double maxTotalWeight = currentWeights.size() == 0 ? 0 : currentWeights.get(currentWeights.size() - 1); 
			// 没有服务器被击中，总重量没有初始化，那就回退到正常的轮询逻辑
			if (maxTotalWeight < 0.001d || serverCount != currentWeights.size()) {
				server =  super.choose(getLoadBalancer(), key);
                if(server == null) {
                    return server;
                }
			} else {
			
				//============权重轮询逻辑=========
				// 随机生成一个权重值（0-最大权重），然后选取一片
				// 这个算法同ZoneAvoidanceRule.randomChooseZone()算法是一样的
				double randomWeight = random.nextDouble() * maxTotalWeight;
	            int n = 0;
	            for (Double d : currentWeights) {
	                if (d >= randomWeight) {
	                    serverIndex = n;
	                    break;
	                } else {
	                    n++;
	                }
	            }
	            server = allList.get(serverIndex);
    		}
    		
            if (server.isAlive()) {
                return (server);
            }
            // Next.
            server = null;
    	}
    	return server;
    }

WeightedResponseTimeRule：

    serverWeightTimer.schedule(new DynamicServerWeightTask(), 0, serverWeightTaskTimerInterval);
    class DynamicServerWeightTask extends TimerTask {
    	@Override
    	public void run() {
    		new ServerWeight().maintainWeights();
    	}
    }

WeightedResponseTimeRule.ServerWeight：

	// 维护权重的方法。权重值的计算规则
	public void maintainWeights() {
		
		// 1、得到所有Server总的rt时间（使用的平均值）
		double totalResponseTime = 0;
		for (Server server : nlb.getAllServers()) {
			totalResponseTime += ssstats.getSingleServerStat(server).getResponseTimeAvg();
		}
		
		// 每个服务器的权重为(所有服务器的响应时间总和- responseTime)
		// 因此，响应时间越长，权重越小，被选择的可能性就越小
		Double weightSoFar = 0.0;
		...
		setWeights(finalWeights);
	}

@Test
public void fun1() throws InterruptedException {
    List<Server> serverList = new ArrayList<>();
    serverList.add(createServer("华南", 1));
    serverList.add(createServer("华东", 1));
    serverList.add(createServer("华东", 2));

    serverList.add(createServer("华北", 1));
    serverList.add(createServer("华北", 2));
    serverList.add(createServer("华北", 3));
    serverList.add(createServer("华北", 4));

    // 轮询策略：因为Servers均来自于lb，所以必须关联上一个lb实例哦
    ILoadBalancer lb = new BaseLoadBalancer();
    lb.addServers(serverList);
    RoundRobinRule rule = new RoundRobinRule(lb);
    while (true) {
        System.out.println(rule.choose(null));
        TimeUnit.SECONDS.sleep(2);
    }
}


private Server createServer(String zone, int index) {
    Server server = new Server("www.baidu" + zone + ".com", index);
    server.setAlive(true);
    server.setReadyToServe(true);
    server.setZone(zone);
    return server;
}

www.baidu华东.com:1
www.baidu华东.com:2
www.baidu华北.com:1
www.baidu华北.com:2
www.baidu华北.com:3
www.baidu华北.com:4
www.baidu华南.com:1
www.baidu华东.com:1
www.baidu华东.com:2
www.baidu华北.com:1
www.baidu华北.com:2
www.baidu华北.com:3
www.baidu华北.com:4
www.baidu华南.com:1
...