负载均衡算法

随机与轮询

随机算法简单高效，适用于节点性能一致的场景。轮询算法按顺序分配请求，保证均匀分布。

public class RoundRobinBalancer {
    private final AtomicInteger index = new AtomicInteger(0);
    private final List<String> servers;

    public String select() {
        int idx = Math.abs(index.getAndIncrement() % servers.size());
        return servers.get(idx);
    }
}

加权轮询与加权随机

为不同性能的节点分配不同权重，高权重节点承担更多请求，充分利用硬件资源差异。

public class WeightedRoundRobin {
    public String select(Map<String, Integer> weights) {
        int totalWeight = weights.values().stream().mapToInt(Integer::intValue).sum();
        int random = ThreadLocalRandom.current().nextInt(totalWeight);
        int current = 0;
        for (Map.Entry<String, Integer> entry : weights.entrySet()) {
            current += entry.getValue();
            if (random < current) return entry.getKey();
        }
        return weights.keySet().iterator().next();
    }
}

最少连接算法

将新请求分配给当前活跃连接数最少的节点，适合处理时间差异大的长连接场景。

public class LeastConnectionBalancer {
    private final ConcurrentHashMap<String, AtomicInteger> connections = new ConcurrentHashMap<>();

    public String select(List<String> servers) {
        return servers.stream()
            .min(Comparator.comparingInt(s -> connections.getOrDefault(s, new AtomicInteger(0)).get()))
            .orElse(servers.get(0));
    }

    public void onConnect(String server) {
        connections.computeIfAbsent(server, k -> new AtomicInteger(0)).incrementAndGet();
    }

    public void onDisconnect(String server) {
        connections.get(server).decrementAndGet();
    }
}

响应时间算法

根据后端节点的实时响应时间动态调整权重，将请求导向性能更优的节点。

public class ResponseTimeBalancer {
    public String select(List<ServerNode> nodes) {
        return nodes.stream()
            .min(Comparator.comparingLong(ServerNode::getAvgResponseTime))
            .map(ServerNode::getAddress)
            .orElse(nodes.get(0).getAddress());
    }
}

算法对比

算法	优点	缺点	适用场景
随机	实现简单	不够均匀	节点性能一致
轮询	均匀分配	不考虑负载	无状态服务
最少连接	动态平衡	计算开销	长连接场景
一致性哈希	缓存友好	数据倾斜	有状态服务