访问后端服务负载均衡的方法

在开发过程中，经常需要请求后端某个服务，而这个服务通常会部署在一个集群上，维护这个服务的同事一般都会给我们一个服务器地址列表，让我们请求这个列表中的服务器。

最简单也是最偷懒的方法，就是任选一个服务器，在代码中只使用这个服务器，每次都请求这个服务器。这么做的问题有两个，一是万一这个服务器出故障了，在故障恢复前所有请求都会失败；二是所有的请求都发送到这个服务器上，当请求量小时还好，请求量大时会这把这个服务器压垮。

稍微好一点的做法是每次都随机从列表中选取一个服务器，然后向该服务器发送请求。这种做法可以保证将请求均匀地分布在集群内的各服务器上。但这种做法也存在一定的问题，当集群内的服务器发生故障的数量多于一台时，如果某次请求随机选取到的服务器无法访问，再次随机选取到的服务器也无法访问，这样就会导致这次请求的时间过长，从而影响用户体验。

由于软硬件故障或网络抖动，集群中的服务器随时可能下线，故障修复后又重新上线。因此，我们的代码应当能做到：

1）将请求均匀地分布到集群中的各服务器上（即实现负载均衡）；

2）当某台服务器下线时（即无法访问时）能将该服务器从可用服务器列表中剔除，不再向该服务器发送请求；

3）当某台服务器故障修复重新上线后，应当能及时发现，并将请求分发到该服务器上。

为了实现这3个目标，我的基本策略是：

1）每次请求时都随机选取一台服务器；

2）当发现某台服务器无法访问时将其标记为不可用，同时为它设置重试时间，在重试时间到达前不再发送请求到该服务器；

3）被标记为不可用的服务器在重试时间到达后允许再次访问，若发现它已恢复服务，则重新将其标记为可用，否则将重试时间延长。

上述策略的第1点保证了请求可以均匀分布；第2点保证了不会将请求发送到出现故障的服务器上；第3点则保证了当服务器故障修复重新上线后可以及时被发现。第3点是基于这样一个假设，即服务器无法访问是暂时的，等待一段时间后它就可以恢复服务。

从上面的策略可以看出，某次请求可能会向被标记为不可用的服务器发送请求，以探测该服务器是否已经从故障中恢复。为了控制单次请求的延时时间，防止在一次请求中多次尝试访问不可用的服务器，向后端服务器集群发送请求的具体步骤分为以下2步：

第1步：从服务器列表中随机选取一个服务器。

获取到的服务器分3种情况：

a.被标记为可用的服务器，返回该服务器；

b.被标记为不可用的服务器，但是已经到达重试时间，返回该服务器；

c.被标记为不可用的服务器，且还没有到达重试时间，返回空。

第1步获取到服务器后，向其发送请求，若请求成功，则请求结束（若该服务器被标记为不可用，还需重新将其标记为可用）；若请求失败，则将其标记为不可用，然后进入第2步。

当然，如果第1步没有获取到服务器，则直接进入第2步。

第2步：从服务器列表中强制获取一个可用的服务器。

到这一步，说明第1步可能已经请求过一次服务了，但是失败了，所以这一步要尽可能地确保请求可以成功。这一步的策略就是，尽可能获取标记为可用的服务器，即只要有可用的服务器，就返回一个可用的服务器；如果没有可用的服务器了，那就退而求其次，返回最早到达重试时间的那个服务器；最后如果所有的服务器都不可用且都还没有到达重试时间，那天王老子也没办法了，只能返回空，表示没有服务器可用。具体实现上来说，为了保证请求尽可能均匀的分布在各服务器上，这一步也是先随机若干次获取可用的服务器，若多次随机获取的都是不可用的服务器，则遍历整个服务器列表，将第一个可用的服务器返回。

第2步获取到服务器后，向其发送请求，若请求成功，则请求结束（若该服务器被标记为不可用，还需重新将其标记为可用）；若请求失败，则将其标记为不可用，然后循环执行第2步，直到请求成功，或者获取不到服务器为止。

不论是第1步还是第2步，如果某个服务器本就处于不可用的状态，在重试后发现其仍然无法访问，还需要将其重试时间加倍。

向服务器集群发起请求分成两步走是有必要的，第一步是为了保证被标记为不可用的服务器能有重试的机会，如果每次都只获取可用的服务器，则那些标记为不可用的服务器在故障恢复后将迟迟不能被发现。第二步强制获取可用的服务器，又确保了在有可用服务器的情况下，在一次请求中不会多次尝试访问不可用的服务器，从而保证了请求的响应时间。

对后端服务器集群进行访问是个通用的功能，我使用了2个类来实现这项功能。ServerInfo类用来描述一个服务器，ServerMgr类用来管理服务器列表。以下是具体代码。

public class ServerInfo {
private String ip;                 // 服务器ip
private int port;                   // 服务器端口
private boolean isValid;      // 服务器是否可用
private long lastTryTime;    // 上次尝试访问时间,单位:秒
private long waitTime;        // 再次尝试访问该服务器前应等待的时间

public ServerInfo(String ip, int port) {
this.ip = ip;
this.port = port;
isValid = true;
lastTryTime = 0;
waitTime = 0;
}
public String getIp() {
return ip;
}

public void setIp(String ip) {
this.ip = ip;
}

public int getPort() {
return port;
}

public void setPort(int port) {
this.port = port;
}

public boolean isValid() {
return isValid;
}

public void setValid(boolean valid) {
isValid = valid;
}

public long getLastTryTime() {
return lastTryTime;
}

public void setLastTryTime(long lastTryTime) {
this.lastTryTime = lastTryTime;
}

public long getWaitTime() {
return waitTime;
}

public void setWaitTime(long waitTime) {
this.waitTime = waitTime;
}

@Override
public String toString() {
return "ServerInfo{" +
"ip='" + ip + '\'' +
", port=" + port +
", isValid=" + isValid +
", lastTryTime=" + lastTryTime +
", waitTime=" + waitTime +
'}';
}
}

其中isValid字段用来标记该服务器是否可用。lastTryTime是服务器不可用时，上一次尝试访问它的时刻；waitTime则是再次重试前应该等待的时间。lastTryTime和waitTime合起来，就可以判断标记为不可用的服务器是否到达重试时间。比如重试时间的初始值为10秒，如果在2017-2-1 18:00:00发现某服务器无法访问，则将其lastTryTime字段设置为2017-2-1 18:00:00（自1970年以来经过的秒数），waitTime设置为10，那么在18:00:10之后就可以再次尝试访问该服务器。

服务器列表管理类：

public class ServerMgr {
// 当服务器不可用时,重试等待时间（默认值）
private static final long WAIT_TIME_DEFAULT = 10;
// 最长重试等待时间（默认值）
private static final long WAIT_TIME_MAX_DEFAULT = 5 * 60;
// 获取服务器时的随机次数（默认值）
private static final int  RANDOM_TRY_TIMES_DEFAULT = 3;

// 服务器列表
private List<ServerInfo> serverInfolist;

// 重试等待时间
private long waitTimeBeforeRetry;

// 最长重试等待时间
private long maxWaitTimeBeforeRetry;

// 获取时随机次数
private int randomCount;

// 服务器个数
private int serverCount;

// 随机数生成器
private Random random;

public ServerMgr(List<ServerInfo> serverInfos) {
serverInfolist = new ArrayList<>();
for (ServerInfo serverInfo : serverInfos) {
serverInfolist.add(new ServerInfo(serverInfo.getIp(), serverInfo.getPort()));
}

waitTimeBeforeRetry = WAIT_TIME_DEFAULT;
maxWaitTimeBeforeRetry = WAIT_TIME_MAX_DEFAULT;
randomCount = RANDOM_TRY_TIMES_DEFAULT;
serverCount= serverInfolist.size();
random = new Random();

// 随机尝试次数不超过服务器数量
// 特别的,若服务器只有1台,则随机尝试次数为1
checkRandomCount();
}

/**
* 随机获取一个服务器,获取的服务器:
*  1)要么是可用的(即serverInfo.isValid()返回为true);
*  2)要么是不可用的(即serverInfo.isValid()返回为false)但是已经到达重试时间;
*  3)要么是不可用的且尚未到达重试时间,此时返回null。
*
*  获取服务器时,调用方应当首先调用本函数获取,对返回值的三种情况,调用方应该做如下处理:
*  (1)返回可用服务器的,如果使用时发现该服务器实际不可用,
*     则应当调用invalidateServer()函数使之失效,然后再次调用getServerByForce()函数强制获取一个服务器;
*  (2)返回不可用服务器的,若重试后发现该服务器恢复可用了,则应当调用validateServer()函数使之生效;
*     若重试后依然不可用,再应当再次调用invalidateServer()函数使之失效;
*     然后调用getServerByForce()强制获取一条连接;
*  (3)返回null的,直接调用getServerByForce()函数强制获取一个服务器。
*
*  获取服务器时,调用方正确的做法为,首先调用本函数获取服务器,若获取不到或者获取的服务器无法访问,则再调用getServerByForce()获取。
*  之所以要求首先调用本函数,是为了重试标记为不可用的服务器,以便短暂不可用的服务器恢复正常后可以及时被我们发现。
*
* @return
*/
public ServerInfo getServerByRandom() {
if (serverInfolist.isEmpty()) {
return null;
}

// 随机获取一个服务器
int index = random.nextInt(this.serverCount);
ServerInfo serverInfo = serverInfolist.get(index);
if (serverInfo.isValid()) {
return serverInfo;
}

long now = new Date().getTime() / 1000;
if (now > serverInfo.getLastTryTime() + serverInfo.getWaitTime()) {
// 服务器已到达重试时间,给它一次机会,重试下
return serverInfo;
}

// 很不幸,获取的服务器既不可用,也没有达到重试时间,返回null
return null;
}

/**
* 强制获取一个服务器。本函数保证:
* 在有可用服务器的情况下,肯定返回一个可用服务器;
*   若所有服务器都不可用,则返回最早到达重试时间的那个服务器;
*     若所有服务器都没有到达重试时间,则返回null。
*
* 调用方应当首先调用getServerByRandom()函数获取服务器,获取不到或者获取的服务器使用后发现确实不可用,再调用本函数获取服务器，
* 否则,当某台服务器暂时不可用又恢复后,将导致该服务器长期饥饿。
*
* 函数首先尝试随机获取一个可用服务器,若尝试若干次都获取不到,
* 则遍历服务器列表池,获取第一个可用服务器;
*   若所有服务器都不可用,则返回最早到达重试时间的那个服务器;
*     若所有服务器都没有到达重试时间,则返回null。
*
* 函数保证了随机性。
*
* @return
*/
public ServerInfo getServerByForce() {
// 避免无休止的随机
int randomCnt = this.randomCount;
while (randomCnt-- > 0) {
ServerInfo svrInfo = getServerByRandom();
if (svrInfo != null && svrInfo.isValid()) {
return svrInfo;
}
}

// 运气真不好,连续随机几次,获取的都是不可用的连接

// 用来记录最早到达重试时间的连接
ServerInfo earliestServerInfo = null;
long now = new Date().getTime() / 1000;

// 遍历服务器列表
for (ServerInfo serverInfo : serverInfolist) {
if (serverInfo.isValid()) {
// 返回第一个可用的服务器
return serverInfo;
}

// 判断服务器是否已达到重试时间
long tryAt = serverInfo.getLastTryTime() + serverInfo.getWaitTime();
if (now >= tryAt) {
if (earliestServerInfo == null ||
tryAt < earliestServerInfo.getLastTryTime() + earliestServerInfo.getWaitTime()) {
earliestServerInfo = serverInfo;
}
}
}

// 当所有的服务器都不可用时，返回最早到达重试时间的那个服务器
return earliestServerInfo;
}

/**
* 标记服务器不可用
* @param serverInfo
*/
public void invalidateServer(ServerInfo serverInfo) {

long waitTime = serverInfo.getWaitTime();
if (waitTime == 0) {
// 从可用变为不可用
waitTime = this.waitTimeBeforeRetry;
} else {
// 重试后依然不可用,延长等待时间
waitTime *= 2;
}

// 重试等待时间不超过最大值
if (waitTime > this.maxWaitTimeBeforeRetry) {
waitTime = this.maxWaitTimeBeforeRetry;
}

serverInfo.setWaitTime(waitTime);
serverInfo.setLastTryTime(new Date().getTime() / 1000);
serverInfo.setValid(false);
}

/**
* 标记服务器可用
* @param serverInfo
*/
public void validateServer(ServerInfo serverInfo) {
serverInfo.setWaitTime(0);
serverInfo.setValid(true);
}

public void setWaitTimeBeforeRetry(long waitTimeBeforeRetry) {
this.waitTimeBeforeRetry = waitTimeBeforeRetry;
}

public void setMaxWaitTimeBeforeRetry(long maxWaitTimeBeforeRetry) {
this.maxWaitTimeBeforeRetry = maxWaitTimeBeforeRetry;
}

public void setRandomCount(int randomCount) {
this.randomCount = randomCount;
checkRandomCount();
}

private void checkRandomCount() {
// 随机尝试次数不超过服务器数量
// 特别的,若服务器只有1台,则随机尝试次数为1
if (randomCount > serverCount) {
randomCount = serverCount;
}
}
}

// 测试程序，伪代码
public class Test {
public static void main(String[] args) throws Exception {
List<ServerInfo> list = new ArrayList<>();
list.add(new ServerInfo("10.94.0.1", 8000));
list.add(new ServerInfo("10.94.0.2", 8000));
list.add(new ServerInfo("10.94.0.3", 8000));
list.add(new ServerInfo("10.94.0.4", 8000));

ServerMgr serverMgr = new ServerMgr(list);

// 第1步，随机获取一个服务器
ServerInfo serverInfo = serverMgr.getServerByRandom();
if (serverInfo == null) {
// 第2步，强制获取一个可用服务器
serverInfo = serverMgr.getServerByForce();
if (serverInfo == null) {
throw new Exception("无可用服务器");
}
}

// 请求内容
String requestMsg = "/get/1";
do {
try {
// 发起请求，requestServer()函数由业务方实现
String res = requestServer(requestMsg, serverInfo.getIp(), serverInfo.getPort());

// 请求成功,发生故障的服务器恢复服务,将其重置为可用状态
if (!serverInfo.isValid()) {
serverMgr.validateServer(serverInfo);
}
System.out.println("请求成功:" + res);
return;
} catch (Exception e) {
System.out.println("服务器不可用:" + serverInfo);
// 服务器无法访问, 将服务器标记为不可用
serverMgr.invalidateServer(serverInfo);
}

//  第2步强制获取可用的服务器
serverInfo = serverMgr.getServerByForce();
if (serverInfo == null) {
throw new Exception("无可用的服务器");
}
} while (true);
}
}