负载均衡算法

不管是Nginx从集群中选出一台提供访问的服务器，还是RPC框架（Dubbo，Spring Cloud等）的消费者从注册中心提供的列表中选出一台提供者，都涉及到负载均衡。

下面介绍几种常见的负载均衡算法，包括轮询法、随机法、客户端地址哈希法、加权轮询法、加权随机法，然后讲解一下Dubbo的随机法。

在开始之前，创建一个类Server，模拟真实场景中的服务器或者提供者。它有两个属性，IP地址和权重值。

/**
 * 模拟服务类
 * @author z_hh
 * @time 2019年1月16日
 */
@AllArgsConstructor
@Getter
@Setter
@ToString
public class Server {
	
	/** IP */
	private String ip;
	
	/** 权重 */
	private int weight = 1;

}

之后的所有算法都将用这个服务列表来模拟。

 

    /**
	 * 模拟服务列表
	 */
	private static final List<Server> SERVERS = new ArrayList<>();
	static {
		SERVERS.add(new Server("192.168.1.1", 1));
		SERVERS.add(new Server("192.168.1.2", 2));
		SERVERS.add(new Server("192.168.1.3", 3));
		SERVERS.add(new Server("192.168.1.4", 2));
		SERVERS.add(new Server("192.168.1.5", 1));
	}

一、轮询法

相当于听歌时的列表循环，按顺序一个一个来，完了又从头开始。需要定义一个记录位置信息的成员变量，并且考虑并发问题。

    /** 下一个位置 */
	private static final AtomicInteger  NEXT_POSITION = new AtomicInteger(0);
	/**
	 * 轮询法
	 * @return
	 */
	public static Server roundRobin() {
		// 如果下一个位置超过了服务列表总数，置为起始值，从头开始
		if (NEXT_POSITION.get() >= SERVERS.size()) {
			NEXT_POSITION.set(0);
		}
		return SERVERS.get(NEXT_POSITION.getAndIncrement());// 先取值，再自增1
	}

二、随机法

相当于听歌时的随机播放，每次都从列表中随便选一个。

    /**
	 * 随机法
	 * @return
	 */
	public static Server random() {
		Random random = new Random();
		int randomPosition = random.nextInt(SERVERS.size());// 0~size减一
		return SERVERS.get(randomPosition);
	}

三、客户端地址哈希法

对客户端的地址（一般是指IP）求出它的哈希值，然后用其对服务列表的个数进行取模运算，得到的结果就是服务列表的其中一个序号。

    /**
	 * 客户端地址哈希法
	 * @param 客户端ip
	 * @return
	 */
	public static Server clientAddrHash(String clientIp) {
		// 计算IP的哈希值
		int hashCode = clientIp.hashCode();
		// 取模，得到服务器序号
		int position = hashCode % SERVERS.size();
		return SERVERS.get(position);
	}

四、加权轮询法

在听歌的时候，如果我们对其中的一些曲目比较喜欢，就会把它们重复添加几次到播放列表中。这个时候，采用列表循环模式播放的话，这些重复的、我们喜欢的歌就会连续播放几次了。

    /**
	 * 加权轮询法
	 * @return
	 */
	public static Server weighRoundRobin() {
		ArrayList<Server> roundServers = new ArrayList<>();
		for (Server server : SERVERS) {
			int weight = server.getWeight();
			for (int i = 0; i < weight; i++) {
                // 按权重多次添加到列表
				roundServers.add(server);
			}
		}
		if (NEXT_POSITION.get() >= roundServers.size()) {
			NEXT_POSITION.set(0);
		}
		return roundServers.get(NEXT_POSITION.getAndIncrement());
	}

五、加权随机法

在听歌的时候，如果我们对其中的一些曲目比较喜欢，就会把它们重复添加几次到播放列表中。这个时候，采用随机播放的话，这些重复的、我们喜欢的歌被播放的概率就比较大了。

    /**
	 * 加权随机法
	 * @return
	 */
	public static Server weightRandom() {
		ArrayList<Server> roundServers = new ArrayList<>();
		for (Server server : SERVERS) {
			int weight = server.getWeight();
			for (int i = 0; i < weight; i++) {
                // 按权重多次添加到列表
				roundServers.add(server);
			}
		}
		Random random = new Random();
		int randomPosition = random.nextInt(roundServers.size());
		return roundServers.get(randomPosition);
	}

六、Dubbo的随机负载均衡算法

这个直接是模仿dubbo的RandomLoadBalance类来写的，就是先判断这些服务的权重是否一样，一样的话，采用加权随机法（不过跟我们上面的不一样），否则，采用随机法。

    private static final Random RANDOM = new Random();
	/**
	 * Dubbo的随机负载均衡算法
	 * @return
	 */
	public static Server dubboRandom() {
		int length = SERVERS.size();// Number of servers
		int totalWeight = 0;// The sum of weights
		boolean sameWeight = true;// Every server has the same weight?
		for (int i = 0; i < length; i++) {
            int weight = SERVERS.get(i).getWeight();
            totalWeight += weight; // Sum
            if (sameWeight && i > 0
                    && weight != SERVERS.get(i - 1).getWeight()) {
                sameWeight = false;
            }
        }
		if (totalWeight > 0 && !sameWeight) {
            // If (not every invoker has the same weight & at least one invoker's weight>0), select randomly based on totalWeight.
            int offset = RANDOM.nextInt(totalWeight);
            // Return a invoker based on the random value.
            for (int i = 0; i < length; i++) {
                offset -= SERVERS.get(i).getWeight();
                if (offset < 0) {
                    return SERVERS.get(i);
                }
            }
        }
        // If all invokers have the same weight value or totalWeight=0, return evenly.
		return SERVERS.get(RANDOM.nextInt(length));
	}