释放双眼，带上耳机，听听看~！
最少活跃数的含义
官方解释：最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差，使慢的机器收到更少。
例如，每个服务维护一个活跃数计数器。当A机器开始处理请求，该计数器加1，此时A还未处理完成。若处理完毕则计数器减1。而B机器接受到请求后很快处理完毕。那么A,B的活跃数分别是1，0。当又产生了一个新的请求，则选择B机器去执行(B活跃数最小)，这样使慢的机器A收到少的请求。
最少活跃数的实现分析
LeastActiveLoadBalance 类实现了最小活跃负载均衡。
实现代码如下。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
2
3 public static final String NAME = "leastactive";
4
5 private final Random random = new Random();
6
7 protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
8 int length = invokers.size(); // 总个数
9 int leastActive = -1; // 最小的活跃数
10 int leastCount = 0; // 相同最小活跃数的个数
11 int[] leastIndexs = new int[length]; // 相同最小活跃数的下标
12 int totalWeight = 0; // 总权重
13 int firstWeight = 0; // 第一个权重，用于于计算是否相同
14 boolean sameWeight = true; // 是否所有权重相同
15 for (int i = 0; i < length; i++) {
16 Invoker<T> invoker = invokers.get(i);
17 int active = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()).getActive(); // 活跃数
18 int weight = invoker.getUrl().getMethodParameter(invocation.getMethodName(), Constants.WEIGHT_KEY, Constants.DEFAULT_WEIGHT); // 权重
19 if (leastActive == -1 || active < leastActive) { // 发现更小的活跃数，重新开始
20 leastActive = active; // 记录最小活跃数
21 leastCount = 1; // 重新统计相同最小活跃数的个数
22 leastIndexs[0] = i; // 重新记录最小活跃数下标
23 totalWeight = weight; // 重新累计总权重
24 firstWeight = weight; // 记录第一个权重
25 sameWeight = true; // 还原权重相同标识
26 } else if (active == leastActive) { // 累计相同最小的活跃数
27 leastIndexs[leastCount ++] = i; // 累计相同最小活跃数下标
28 totalWeight += weight; // 累计总权重
29 // 判断所有权重是否一样
30 if (sameWeight && i > 0
31 && weight != firstWeight) {
32 sameWeight = false;
33 }
34 }
35 }
36 // assert(leastCount > 0)
37 if (leastCount == 1) {
38 // 如果只有一个最小则直接返回
39 return invokers.get(leastIndexs[0]);
40 }
41 if (! sameWeight && totalWeight > 0) {
42 // 如果权重不相同且权重大于0则按总权重数随机
43 int offsetWeight = random.nextInt(totalWeight);
44 // 并确定随机值落在哪个片断上
45 for (int i = 0; i < leastCount; i++) {
46 int leastIndex = leastIndexs[i];
47 offsetWeight -= getWeight(invokers.get(leastIndex), invocation);
48 if (offsetWeight <= 0)
49 return invokers.get(leastIndex);
50 }
51 }
52 // 如果权重相同或权重为0则均等随机
53 return invokers.get(leastIndexs[random.nextInt(leastCount)]);
54 }
55}
56
这个算法，总体上可分为两部分。
- 活跃数与权重统计。
- 选择invoker。
活跃数与权重统计
统计最少活跃invoker的数量，总权重，及当有多个最小活跃数相同的Invoker时其权重(weight)是否相等。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2 Invoker<T> invoker = invokers.get(i);
3 int active = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()).getActive(); // 活跃数
4 int weight = invoker.getUrl().getMethodParameter(invocation.getMethodName(), Constants.WEIGHT_KEY, Constants.DEFAULT_WEIGHT); // 权重
5 if (leastActive == -1 || active < leastActive) { // 发现更小的活跃数，重新开始
6 leastActive = active; // 记录最小活跃数
7 leastCount = 1; // 重新统计相同最小活跃数的个数
8 leastIndexs[0] = i; // 重新记录最小活跃数下标
9 totalWeight = weight; // 重新累计总权重
10 firstWeight = weight; // 记录第一个权重
11 sameWeight = true; // 还原权重相同标识
12 } else if (active == leastActive) { // 累计相同最小的活跃数
13 leastIndexs[leastCount ++] = i; // 累计相同最小活跃数下标
14 totalWeight += weight; // 累计总权重
15 // 判断所有权重是否一样
16 if (sameWeight && i > 0
17 && weight != firstWeight) {
18 sameWeight = false;
19 }
20 }
21 }
22
选择invoker
如果具有最小活跃数的invoker只有一个，直接返回该Invoker。
2
3
4
5
2 // 如果只有一个最小则直接返回
3 return invokers.get(leastIndexs[0]);
4 }
5
如果最小活跃数的invoker有多个，且权重不相等同时总权重大于0，这是随机生成一个权重，范围在[0，totalWeight) 间内。最后根据随机生成的权重，来选择invoker。
2
3
4
5
6
7
8
9
10
11
12
2 // 如果权重不相同且权重大于0则按总权重数随机
3 int offsetWeight = random.nextInt(totalWeight);
4 // 并确定随机值落在哪个片断上
5 for (int i = 0; i < leastCount; i++) {
6 int leastIndex = leastIndexs[i];
7 offsetWeight -= getWeight(invokers.get(leastIndex), invocation);
8 if (offsetWeight <= 0)
9 return invokers.get(leastIndex);
10 }
11 }
12
例如有3个invoker，权重分别为100,200,300
经过前面的统计，记录了总权重是600，随机生成的权重范围是[0,600) ，若随机值为180，那么用随机生成的权重180依次去A(100),B(200),C(300)的权重，当减到B时候结果 <= 0，因此选择B。
所以通过这种方法，即用随机权重值从前向后减每个invoker的权重，结果<=0说明落在哪个invoker的范围内，最终确定invoker。
如果不满足前面3中情况，则从最小活跃数相同的invoker中随机选择一个invoker。
2
3
2return invokers.get(leastIndexs[random.nextInt(leastCount)]);
3
活跃数的变化
活跃数的修改发生在com.alibaba.dubbo.rpc.filter.ActiveLimitFilter中。若未配置actives属性，则每进行一次调用前该invoker关联的活跃数加1，调用结束后活跃数减1。
beginCount对活跃数加1，endCount对活跃数减1。
2
3
4
5
6
7
8
9
10
11
2 RpcStatus.beginCount(url, methodName);
3 try {
4 Result result = invoker.invoke(invocation);
5 RpcStatus.endCount(url, methodName, System.currentTimeMillis() - begin, true);
6 return result;
7 } catch (RuntimeException t) {
8 RpcStatus.endCount(url, methodName, System.currentTimeMillis() - begin, false);
9 throw t;
10 }
11
如果使用LeastActive负载均衡，则需要启用ActiveLimitFilter，这样活跃数才会变化。
因此需要配置filter，filter 为 “activelimit”。
2
2
dubbo中包含一些内置filter,其描述在如下文件。
