一、负载均衡的方式
在分布式集群架构下，负载均衡很重要。集群本来就是为了分担压力，负载均衡做的不好，就会失去了集群的意义。
1.按照权重随机分配
按照权重随机分配，即是不均等随机事件。比如一块不均匀的硬币，字面30%概率，花面70%概率。这种就是不均等的随机事件。
从数学上看，即是一个区间0-10，然后均等随机产生0-10的随机数。然后在这个区间上划分，0-3，3-6,6-10.分别把这个三个区间看做三个随机事件，那么这个三个随机事件的概率即是30%，30%，40%。
列子：
权重分别为[2,4,8]，权重和为14，那么前面三个权重为2,4,8的三个事件就对应[0,2,6,14]这个三个区间。比如6-14表示权重为8的随机事件的概率为8/14。所以当产生一个随机数时，通过遍历权重数组，减等，当小于0时，他就落在那个权重事件上。比如：随机数5落在2-6之间，2-6对应的是权重为4这个事件，所以他属于权重为4的这个随机事件。
@Override
protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
int length = invokers.size(); // 一个invoker可以理解为代表一台可选择的机子
int totalWeight = 0; // 所有权重值和，即为上述0-10
boolean sameWeight = true; // Every invoker has the same weight?
for (int i = 0; i < length; i++) {
int weight = getWeight(invokers.get(i), invocation);
totalWeight += weight; // Sum
if (sameWeight && i > 0
&& weight != getWeight(invokers.get(i - 1), invocation)) {
sameWeight = false;
}
}
if (totalWeight > 0 && !sameWeight) {
// 确定随机的事件落在哪个范围内
int offset = random.nextInt(totalWeight);
// Return a invoker based on the random value.
for (int i = 0; i < length; i++) {
offset -= getWeight(invokers.get(i), invocation);
if (offset < 0) {
return invokers.get(i);
}
}
}
//如果所有权重相同，均等随机
return invokers.get(random.nextInt(length));
}
2.轮询
当多线程出现时，使用原子类的整数去取莫轮询节点。
注意：sequences是成员变量，每次调用函数所有的权重都回归最初。
@Override
protected <T> Invoker<T> doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
String key = invokers.get(0).getUrl().getServiceKey() + "." + invocation.getMethodName();
int length = invokers.size(); // Number of invokers
int maxWeight = 0; // The maximum weight
int minWeight = Integer.MAX_VALUE; // The minimum weight
final LinkedHashMap<Invoker<T>, IntegerWrapper> invokerToWeightMap = new LinkedHashMap<Invoker<T>, IntegerWrapper>();
int weightSum = 0;
for (int i = 0; i < length; i++) {
int weight = getWeight(invokers.get(i), invocation);
maxWeight = Math.max(maxWeight, weight); // Choose the maximum weight
minWeight = Math.min(minWeight, weight); // Choose the minimum weight
if (weight > 0) {
invokerToWeightMap.put(invokers.get(i), new IntegerWrapper(weight));
weightSum += weight;
}
}
//sequence是一个并发类型
//private final ConcurrentMap<String, AtomicPositiveInteger> sequences = new
//ConcurrentHashMap<String, AtomicPositiveInteger>();
AtomicPositiveInteger sequence = sequences.get(key);
if (sequence == null) {
sequences.putIfAbsent(key, new AtomicPositiveInteger());
sequence = sequences.get(key);
}
//获取并自增，那么越往后的请求就会值越大，在下面取莫的时候向后推。越后面的请求使用后面的节点
//当这个值超过总权重后，又从第一个开始。这就是轮询了
int currentSequence = sequence.getAndIncrement();
//当所有权重不相同的时候，取请求的顺序值来取莫找
if (maxWeight > 0 && minWeight < maxWeight) {
int mod = currentSequence % weightSum;
//如果莫归零，刚好到的那个位置权重是零，再继续循环，重新找到第一个不为零的权重的invoker。
//所以就会出现权重越大，机会就越多，在按照轮询的前提下。
for (int i = 0; i < maxWeight; i++) {
for (Map.Entry<Invoker<T>, IntegerWrapper> each : invokerToWeightMap.entrySet()) {
final Invoker<T> k = each.getKey();
final IntegerWrapper v = each.getValue();
if (mod == 0 && v.getValue() > 0) {
return k;
}
if (v.getValue() > 0) {
//权重越小的节点，就可能越少的机会使用，这就是按按照权重概率来轮询
v.decrement();
mod--;
}
}
}
}
// Round robin
return invokers.get(currentSequence % length);
}
3.Hash方式
使用某种hash算法，同一请求总是会hash到同一台机子上。
传统的hash算法，存在当hash区间变化时，同样的值hash后的位置不一样了。而一致性hash算法把请求，节点都hash后，放到一个圆环上，按照顺时针转动到的第一个节点为结果。这样就减少了结果的变化。还可以通过增加虚拟节点的方式均衡hash后的概率问题，当然增加节点需要交叉增加。
1.怎么保证服务器少的情况下，hash的结果变化不大。
把消费者，提供者都去hash,hash的结果映射到一个环上。然后，要判断的那个消费者访问那个提供者的时候，进行顺时针的转动。遇到的第一个提供者节点就是。
2.怎么保证概率的问题
交叉的防止虚拟节点，只要节点够多，那就近似是想等的。
详见：一致性hash详解释
4.最少访问原则
如果有多台机子的最少活跃数相同，在这几个中使用第一种按权重随机的方式
最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。
使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。
比如:同样是进行了10个请求，在一分钟内，A只处理了两个，B处理了5个。那么A的机会就更少，那么就会保证的系统整体的速度。
