【源码品读】负载均衡策略解析-1

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

protected int chooseRandomInt(int serverCount) {
	return ThreadLocalRandom.current().nextInt(serverCount);
}

/**
 * Randomly choose from all living servers
 */
@edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE")
public Server choose(ILoadBalancer lb, Object key) {
	if (lb == null) {
		return null;
	}
	Server server = null;

	while (server == null) {
		if (Thread.interrupted()) {
			return null;
		}
		List<Server> upList = lb.getReachableServers();
		List<Server> allList = lb.getAllServers();

		int serverCount = allList.size();
		if (serverCount == 0) {
			/*
			 * No servers. End regardless of pass, because subsequent passes
			 * only get more restrictive.
			 */
			return null;
		}

		int index = chooseRandomInt(serverCount);
		server = upList.get(index);

		if (server == null) {
			/*
			 * The only time this should happen is if the server list were
			 * somehow trimmed. This is a transient condition. Retry after
			 * yielding.
			 */
			Thread.yield();
			continue;
		}

		if (server.isAlive()) {
			return (server);
		}

		// Shouldn't actually happen.. but must be transient or a bug.
		server = null;
		Thread.yield();
	}

	return server;

}

public Server choose(ILoadBalancer lb, Object key) {
	if (lb == null) {
		log.warn("no load balancer");
		return null;
	}

	Server server = null;
	int count = 0;
	while (server == null && count++ < 10) {
		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);

		if (server == null) {
			/* Transient. */
			Thread.yield();
			continue;
		}

		if (server.isAlive() && (server.isReadyToServe())) {
			return (server);
		}

		// Next.
		server = null;
	}

	if (count >= 10) {
		log.warn("No available alive servers after 10 tries from load balancer: "
				+ lb);
	}
	return server;
}

/**
 * Inspired by the implementation of {@link AtomicInteger#incrementAndGet()}.
 *
 * @param modulo The modulo to bound the value of the counter.
 * @return The next value.
 */
private int incrementAndGetModulo(int modulo) {
	for (;;) {
		int current = nextServerCyclicCounter.get();
		int next = (current + 1) % modulo;
		if (nextServerCyclicCounter.compareAndSet(current, next))
			return next;
	}
}

private AtomicInteger nextServerCyclicCounter;

public final boolean compareAndSet(int expect, int update) {
	return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public RoundRobinRule() {
	nextServerCyclicCounter = new AtomicInteger(0);
}