@SPI(RandomLoadBalance.NAME)
public interface LoadBalance {

    /**
     * select one invoker in list.
     *
     * 从 Invoker 集合中，选择一个
     *
     * @param invokers   invokers.
     * @param url        refer url
     * @param invocation invocation.
     * @return selected invoker.
     */
    @Adaptive("loadbalance")
    <T> Invoker<T> select(List<Invoker<T>> invokers, URL url, Invocation invocation) throws RpcException;

}

    @Override
public <T> Invoker<T> select(List<Invoker<T>> invokers, URL url, Invocation invocation) {
    if (invokers == null || invokers.isEmpty()) {
        return null;
    }
    if (invokers.size() == 1) {
        return invokers.get(0);
    }
    return doSelect(invokers, url, invocation);
}

protected int getWeight(Invoker<?> invoker, Invocation invocation) {
    // 获得 weight 配置，即服务权重。默认为 100
    int weight = invoker.getUrl().getMethodParameter(invocation.getMethodName(), Constants.WEIGHT_KEY, Constants.DEFAULT_WEIGHT);
    if (weight > 0) {
        long timestamp = invoker.getUrl().getParameter(Constants.REMOTE_TIMESTAMP_KEY, 0L);
        if (timestamp > 0L) {
            // 获得启动总时长
            int uptime = (int) (System.currentTimeMillis() - timestamp);
            // 获得预热需要总时长。默认为 10 * 60 * 1000 = 10 分钟
            int warmup = invoker.getUrl().getParameter(Constants.WARMUP_KEY, Constants.DEFAULT_WARMUP);
            // 处于预热中，计算当前的权重
            if (uptime > 0 && uptime < warmup) {
                weight = calculateWarmupWeight(uptime, warmup, weight);
            }
        }
    }
    return weight;
}

 1: public class RandomLoadBalance extends AbstractLoadBalance {
 2: 
 3:     public static final String NAME = "random";
 4: 
 5:     private final Random random = new Random();
 6: 
 7:     @Override
 8:     protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
 9:         int length = invokers.size(); // Number of invokers
10:         int totalWeight = 0; // The sum of weights
11:         boolean sameWeight = true; // Every invoker has the same weight?
12:         // 计算总权限
13:         for (int i = 0; i < length; i++) {
14:             int weight = getWeight(invokers.get(i), invocation); // 获得权重
15:             totalWeight += weight; // Sum
16:             if (sameWeight && i > 0 && weight != getWeight(invokers.get(i - 1), invocation)) {
17:                 sameWeight = false;
18:             }
19:         }
20:         // 权重不相等，随机后，判断在哪个 Invoker 的权重区间中
21:         if (totalWeight > 0 && !sameWeight) {
22:             // 随机
23:             // If (not every invoker has the same weight & at least one invoker's weight>0), select randomly based on totalWeight.
24:             int offset = random.nextInt(totalWeight);
25:             // Return a invoker based on the random value.
26:             // 区间判断
27:             for (Invoker<T> invoker : invokers) {
28:                 offset -= getWeight(invoker, invocation);
29:                 if (offset < 0) {
30:                     return invoker;
31:                 }
32:             }
33:         }
34:         // 权重相等，平均随机
35:         // If all invokers have the same weight value or totalWeight=0, return evenly.
36:         return invokers.get(random.nextInt(length));
37:     }
38: 
39: }

 1: public class RoundRobinLoadBalance extends AbstractLoadBalance {
 2: 
 3:     public static final String NAME = "roundrobin";
 4: 
 5:     /**
 6:      * 服务方法与计数器的映射
 7:      *
 8:      * KEY：serviceKey + "." + methodName
 9:      */
10:     private final ConcurrentMap<String, AtomicPositiveInteger> sequences = new ConcurrentHashMap<String, AtomicPositiveInteger>();
11: 
12:     @Override
13:     protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
14:         String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
15:         int length = invokers.size(); // Number of invokers
16:         int maxWeight = 0; // The maximum weight
17:         int minWeight = Integer.MAX_VALUE; // The minimum weight
18:         final LinkedHashMap<Invoker<T>, IntegerWrapper> invokerToWeightMap = new LinkedHashMap<Invoker<T>, IntegerWrapper>();
19:         int weightSum = 0;
20:         // 计算最小、最大权重，总的权重和。
21:         for (int i = 0; i < length; i++) {
22:             int weight = getWeight(invokers.get(i), invocation);
23:             maxWeight = Math.max(maxWeight, weight); // Choose the maximum weight
24:             minWeight = Math.min(minWeight, weight); // Choose the minimum weight
25:             if (weight > 0) {
26:                 invokerToWeightMap.put(invokers.get(i), new IntegerWrapper(weight));
27:                 weightSum += weight;
28:             }
29:         }
30:         // 获得 AtomicPositiveInteger 对象
31:         AtomicPositiveInteger sequence = sequences.get(key);
32:         if (sequence == null) {
33:             sequences.putIfAbsent(key, new AtomicPositiveInteger());
34:             sequence = sequences.get(key);
35:         }
36:         // 获得当前顺序号，并递增 + 1
37:         int currentSequence = sequence.getAndIncrement();
38:         // 权重不相等，顺序根据权重分配
39:         if (maxWeight > 0 && minWeight < maxWeight) {
40:             int mod = currentSequence % weightSum; // 剩余权重
41:             for (int i = 0; i < maxWeight; i++) { // 循环最大权重
42:                 for (Map.Entry<Invoker<T>, IntegerWrapper> each : invokerToWeightMap.entrySet()) { // 循环 Invoker 集合
43:                     final Invoker<T> k = each.getKey();
44:                     final IntegerWrapper v = each.getValue();
45:                     // 剩余权重归 0 ，当前 Invoker 还有剩余权重，返回该 Invoker 对象
46:                     if (mod == 0 && v.getValue() > 0) {
47:                         return k;
48:                     }
49:                     // 若 Invoker 还有权重值，扣除它( value )和剩余权重( mod )。
50:                     if (v.getValue() > 0) {
51:                         v.decrement();
52:                         mod--;
53:                     }
54:                 }
55:             }
56:         }
57:         // 权重相等，平均顺序获得
58:         // Round robin
59:         return invokers.get(currentSequence % length);
60:     }
61:     
62: }

 1: public class LeastActiveLoadBalance extends AbstractLoadBalance {
 2: 
 3:     public static final String NAME = "leastactive";
 4: 
 5:     private final Random random = new Random();
 6: 
 7:     @Override
 8:     protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
 9:         int length = invokers.size(); // 总个数
10:         int leastActive = -1; // 最小的活跃数
11:         int leastCount = 0; // 相同最小活跃数的个数
12:         int[] leastIndexes = new int[length]; // 相同最小活跃数的下标
13:         int totalWeight = 0; // 总权重
14:         int firstWeight = 0; // 第一个权重，用于于计算是否相同
15:         boolean sameWeight = true; // 是否所有权重相同
16:         // 计算获得相同最小活跃数的数组和个数
17:         for (int i = 0; i < length; i++) {
18:             Invoker<T> invoker = invokers.get(i);
19:             int active = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()).getActive(); // 活跃数
20:             int weight = invoker.getUrl().getMethodParameter(invocation.getMethodName(), Constants.WEIGHT_KEY, Constants.DEFAULT_WEIGHT); // 权重
21:             if (leastActive == -1 || active < leastActive) { // 发现更小的活跃数，重新开始
22:                 leastActive = active; // 记录最小活跃数
23:                 leastCount = 1; // 重新统计相同最小活跃数的个数
24:                 leastIndexes[0] = i; // 重新记录最小活跃数下标
25:                 totalWeight = weight; // 重新累计总权重
26:                 firstWeight = weight; // 记录第一个权重
27:                 sameWeight = true; // 还原权重相同标识
28:             } else if (active == leastActive) { // 累计相同最小的活跃数
29:                 leastIndexes[leastCount++] = i; // 累计相同最小活跃数下标
30:                 totalWeight += weight; // 累计总权重
31:                 // 判断所有权重是否一样
32:                 if (sameWeight && weight != firstWeight) {
33:                     sameWeight = false;
34:                 }
35:             }
36:         }
37:         // assert(leastCount > 0)
38:         if (leastCount == 1) {
39:             // 如果只有一个最小则直接返回
40:             return invokers.get(leastIndexes[0]);
41:         }
42:         if (!sameWeight && totalWeight > 0) {
43:             // 如果权重不相同且权重大于0则按总权重数随机
44:             int offsetWeight = random.nextInt(totalWeight);
45:             // 并确定随机值落在哪个片断上
46:             for (int i = 0; i < leastCount; i++) {
47:                 int leastIndex = leastIndexes[i];
48:                 offsetWeight -= getWeight(invokers.get(leastIndex), invocation);
49:                 if (offsetWeight <= 0) {
50:                     return invokers.get(leastIndex);
51:                 }
52:             }
53:         }
54:         // 如果权重相同或权重为0则均等随机
55:         return invokers.get(leastIndexes[random.nextInt(leastCount)]);
56:     }
57: 
58: }

 1: public class ConsistentHashLoadBalance extends AbstractLoadBalance {
 2: 
 3:     /**
 4:      * 服务方法与一致性哈希选择器的映射
 5:      *
 6:      * KEY：serviceKey + "." + methodName
 7:      */
 8:     private final ConcurrentMap<String, ConsistentHashSelector<?>> selectors = new ConcurrentHashMap<String, ConsistentHashSelector<?>>();
 9: 
10:     @SuppressWarnings("unchecked")
11:     @Override
12:     protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
13:         String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
14:         // 基于 invokers 集合，根据对象内存地址来计算定义哈希值
15:         int identityHashCode = System.identityHashCode(invokers);
16:         // 获得 ConsistentHashSelector 对象。若为空，或者定义哈希值变更（说明 invokers 集合发生变化），进行创建新的 ConsistentHashSelector 对象
17:         ConsistentHashSelector<T> selector = (ConsistentHashSelector<T>) selectors.get(key);
18:         if (selector == null || selector.identityHashCode != identityHashCode) {
19:             selectors.put(key, new ConsistentHashSelector<T>(invokers, invocation.getMethodName(), identityHashCode));
20:             selector = (ConsistentHashSelector<T>) selectors.get(key);
21:         }
22:         return selector.select(invocation);
23:     }
24: }

/**
 * 虚拟节点与 Invoker 的映射关系
 */
private final TreeMap<Long, Invoker<T>> virtualInvokers;
/**
 * 每个Invoker 对应的虚拟节点数
 */
private final int replicaNumber;
/**
 * 定义哈希值
 */
private final int identityHashCode;
/**
 * 取值参数位置数组
 */
private final int[] argumentIndex;

  1: ConsistentHashSelector(List<Invoker<T>> invokers, String methodName, int identityHashCode) {
  2:     this.virtualInvokers = new TreeMap<Long, Invoker<T>>();
  3:     // 设置 identityHashCode
  4:     this.identityHashCode = identityHashCode;
  5:     URL url = invokers.get(0).getUrl();
  6:     // 初始化 replicaNumber
  7:     this.replicaNumber = url.getMethodParameter(methodName, "hash.nodes", 160);
  8:     // 初始化 argumentIndex
  9:     String[] index = Constants.COMMA_SPLIT_PATTERN.split(url.getMethodParameter(methodName, "hash.arguments", "0"));
 10:     argumentIndex = new int[index.length];
 11:     for (int i = 0; i < index.length; i++) {
 12:         argumentIndex[i] = Integer.parseInt(index[i]);
 13:     }
 14:     // 初始化 virtualInvokers
 15:     for (Invoker<T> invoker : invokers) {
 16:         String address = invoker.getUrl().getAddress();
 17:         // 每四个虚拟结点为一组，为什么这样？下面会说到
 18:         for (int i = 0; i < replicaNumber / 4; i++) {
 19:             // 这组虚拟结点得到惟一名称
 20:             byte[] digest = md5(address + i);
 21:             // Md5是一个16字节长度的数组，将16字节的数组每四个字节一组，分别对应一个虚拟结点，这就是为什么上面把虚拟结点四个划分一组的原因
 22:             for (int h = 0; h < 4; h++) {
 23:                 // 对于每四个字节，组成一个long值数值，做为这个虚拟节点的在环中的惟一key
 24:                 long m = hash(digest, h);
 25:                 virtualInvokers.put(m, invoker);
 26:             }
 27:         }
 28:     }
 29: }

public Invoker<T> select(Invocation invocation) {
    // 基于方法参数，获得 KEY
    String key = toKey(invocation.getArguments());
    // 计算 MD5 值
    byte[] digest = md5(key);
    // 计算 KEY 值
    return selectForKey(hash(digest, 0));
}