Dubbo 负载均衡策略#

public class RandomLoadBalance extends AbstractLoadBalance {

    @Override
    protected <T> T doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
        int length = invokers.size();
        boolean sameWeight = true;
        int[] weights = new int[length];

        // 1. 计算每个 Invoker 的权重
        for (int i = 0; i < length; i++) {
            int weight = getWeight(invokers.get(i), invocation);
            weights[i] = weight;

            // 检查权重是否相同
            if (sameWeight && i > 0 && weight != weights[i-1]) {
                sameWeight = false;
            }
        }

        // 2. 权重相同 -> 纯随机
        if (sameWeight) {
            return invokers.get(ThreadLocalRandom.current().nextInt(length));
        }

        // 3. 权重不同 -> 加权随机（核心算法）
        int offset = ThreadLocalRandom.current().nextInt(totalWeight);
        for (int i = 0; i < length; i++) {
            offset -= weights[i];
            if (offset < 0) {
                return invokers.get(i);
            }
        }
        return invokers.get(invokers.size() - 1);
    }
}

public class RoundRobinLoadBalance extends AbstractLoadBalance {

    // 每个 Invoker 的当前 currentWeight
    private ConcurrentMap<String, WeightedRoundRobin> weightMap = new ConcurrentHashMap<>();

    @Override
    protected <T> T doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
        String key = invokers.get(0).getUrl().getServiceKey();
        int totalWeight = 0;
        long maxCurrent = Long.MIN_VALUE;
        Invoker<T> selectedInvoker = null;
        WeightedRoundRobin selectedWRR = null;

        // 1. 遍历所有 Invoker，找 currentWeight 最大的
        for (Invoker<T> invoker : invokers) {
            String identifyString = invoker.getUrl().identifyString();
            WeightedRoundRobin weightedRoundRobin = weightMap.computeIfAbsent(
                identifyString, k -> new WeightedRoundRobin()
            );

            // 2. 更新 effectiveWeight（权重不变）
            int weight = getWeight(invoker, invocation);
            weightedRoundRobin.setWeight(weight);

            // 3. 核心：currentWeight += effectiveWeight
            //    每次轮询都增加，增加幅度取决于权重
            weightedRoundRobin.incurCounter();

            // 4. 比较 currentWeight，找最大的
            if (weightedRoundRobin.getCurrentWeight() > maxCurrent) {
                maxCurrent = weightedRoundRobin.getCurrentWeight();
                selectedInvoker = invoker;
                selectedWRR = weightedRoundRobin;
            }
            totalWeight += weight;
        }

        // 5. 选中后，currentWeight -= totalWeight
        //    相当于"还债"，让其他节点有机会被选中
        if (selectedInvoker != null) {
            selectedWRR.sel(totalWeight);
            return selectedInvoker;
        }

        return invokers.get(0);
    }
}

public class LeastActiveLoadBalance extends AbstractLoadBalance {

    @Override
    protected <T> T doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
        int length = invokers.size();
        int leastActive = -1;
        int totalWeight = 0;
        int leastCount = 0;
        int[] weights = new int[length];

        // 1. 找到最少活跃数的 Invoker
        for (int i = 0; i < length; i++) {
            Invoker<T> invoker = invokers.get(i);
            int active = RpcStatus.getStatus(invoker.getUrl())
                .getActive(); // 当前活跃请求数
            int weight = getWeight(invoker, invocation);
            weights[i] = weight;

            if (leastActive == -1 || active < leastActive) {
                leastActive = active;
                leastCount = 1;
                totalWeight = weight;
            } else if (active == leastActive) {
                leastCount++;
                totalWeight += weight;
            }
        }

        // 2. 活跃数相同 -> 加权随机
        if (leastCount == 1 && totalWeight > 0) {
            // 加权随机选择
        }
        // 3. 活跃数不同 -> 选择最少活跃数的
        return leastActiveInvoker;
    }
}

// Dubbo ConsistentHashLoadBalance 默认配置
@Activate(group = Constants.CONSUMER, value = Constants.LOADBALANCE_KEY)
public class ConsistentHashLoadBalance<T> extends AbstractLoadBalance {

    // 默认 160 个虚拟节点
    private static final int DEFAULT_VIRTUAL_NODES = 160;

    // 虚拟节点哈希环
    private final TreeMap<Long, Invoker<T>> virtualInvokers = new TreeMap<>();

    @Override
    protected <T> T doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
        // 对请求参数做哈希（默认只用第一个参数）
        String key = getKey(invocation);
        long hash = hash(key);

        // 顺时针找到第一个虚拟节点
        Map.Entry<Long, Invoker<T>> entry =
            virtualInvokers.tailMap(hash, true).firstEntry();

        if (entry == null) {
            entry = virtualInvokers.firstEntry();
        }
        return entry.getValue();
    }
}

public class ShortestResponseLoadBalance extends AbstractLoadBalance {

    @Override
    protected <T> T doSelect(List<Invoker<T>> invokers, URL url, Invocation invocation) {
        // 计算每个 Invoker 的预估响应时间
        // 预估响应时间 = 平均RT * (当前活跃数 + 1)
        // 选择预估响应时间最短的
    }
}