脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java负载均衡算法

从零带你手写Java七种负载均衡算法实现方案

 更新时间：2026年02月13日 09:27:35   作者：大黄评测  
在分布式系统,微服务架构以及高并发场景中,负载均衡是一项至关重要的技术本文将带你纯手写实现七种常见的负载均衡算法,全部使用 Java 编写,不依赖任何第三方框架,帮助你深入理解其核心原理与适用场景

在分布式系统、微服务架构以及高并发场景中，负载均衡（Load Balancing） 是一项至关重要的技术。它能够将请求合理地分发到多个服务节点上，从而提升系统整体的吞吐量、可用性和容错能力。

本文将带你纯手撸实现七种常见的负载均衡算法，全部使用 Java 编写，不依赖任何第三方框架，帮助你深入理解其核心原理与适用场景。

准备工作

首先定义一个通用的服务节点接口：

public class Server {
    private String host;
    private int port;
    private int weight; // 权重，用于加权类算法

    public Server(String host, int port) {
        this(host, port, 1);
    }

    public Server(String ​​host, int port, int weight) {
        this.host = host;
        this.port = port;
        this.weight = weight;
    }

    // getters & setters
    public String getHost() { return host; }
    public int getPort() { return port; }
    public int getWeight() { return weight; }
    public void setWeight(int weight) { this.weight = weight; }

    @Override
    public String toString() {
        return host + ":" + port + "(w=" + weight + ")";
    }
}

所有算法都将实现以下接口：

public interface LoadBalancer {
    Server select(List<Server> servers);
}

1. 随机（Random）

最简单的策略：从可用节点中随机选择一个。

public class RandomLoadBalancer implements LoadBalancer {
    private final Random random = new Random();

    @Override
    public Server select(List<Server> servers) {
        if (servers == null || servers.isEmpty()) return null;
        int index = random.nextInt(servers.size());
        return servers.get(index);
    }
}

优点：简单、无状态

缺点：无法保证请求分布均匀（尤其在短时间窗口内）

2. 轮询（Round Robin）

按顺序依次选择节点，循环往复。

public class RoundRobinLoadBalancer implements LoadBalancer {
    private AtomicInteger index = new AtomicInteger(0);

    @Override
    public Server select(List<Server> servers) {
        if (servers == null || servers.isEmpty()) return null;
        int i = index.getAndIncrement() % servers.size();
        // 处理负数（虽然 unlikely）
        if (i < 0) i += servers.size();
        return servers.get(i);
    }
}

优点：请求分布均匀

缺点：未考虑服务器性能差异

3. 加权轮询（Weighted Round Robin）

为每个节点分配权重，高权重节点被选中的频率更高。

实现思路：采用“最大公约数 + 当前轮次”方式，避免预生成列表（节省内存）。

public class WeightedRoundRobinLoadBalancer implements LoadBalancer {
    private AtomicInteger currentPos = new AtomicInteger(0);

    @Override
    public Server select(List<Server> servers) {
        if (servers == null || servers.isEmpty()) return null;

        // 计算总权重
        int totalWeight = servers.stream().mapToInt(Server::getWeight).sum();
        if (totalWeight <= 0) {
            // 退化为普通轮询
            return new RoundRobinLoadBalancer().select(servers);
        }

        int current = currentPos.getAndIncrement() % totalWeight;
        if (current < 0) current += totalWeight;

        // 遍历找到对应节点
        for (Server server : servers) {
            if (current < server.getWeight()) {
                return server;
            }
            current -= server.getWeight();
        }

        // 理论上不会走到这里
        return servers.get(servers.size() - 1);
    }
}

注意：上述实现是简化版。工业级实现（如 Nginx）通常使用更复杂的平滑加权轮询（Smooth Weighted Round Robin），以避免连续选中高权重节点。

4. 平滑加权轮询（Smooth Weighted Round Robin）

由 Nginx 提出，解决加权轮询中“高权重节点连续被选中”的问题。

public class SmoothWeightedRoundRobinLoadBalancer implements LoadBalancer {

    private final Map<Server, Integer> currentWeights = new ConcurrentHashMap<>();

    @Override
    public Server select(List<Server> servers) {
        if (servers == null || servers.isEmpty()) return null;

        int totalWeight = 0;
        Server best = null;
        int max = Integer.MIN_VALUE;

        for (Server server : servers) {
            int weight = server.getWeight();
            if (weight <= 0) weight = 1;

            totalWeight += weight;
            int current = currentWeights.getOrDefault(server, 0) + weight;
            currentWeights.put(server, current);

            if (current > max) {
                max = current;
                best = server;
            }
        }

        if (best != null) {
            currentWeights.put(best, max - totalWeight);
        }

        return best;
    }
}

优点：权重分配更平滑，高权重节点不会连续被选中

示例：A(w=5), B(w=1) → 顺序为 A,A,A,A,A,B,... 而非 A,A,A,A,A,A,...

5. 最少连接（Least Connections）

将请求分发给当前连接数最少的节点。

为简化，我们用一个 Map<Server, AtomicInteger> 模拟连接计数。

public class LeastConnectionsLoadBalancer implements LoadBalancer {
    private final Map<Server, AtomicInteger> connectionCounts = new ConcurrentHashMap<>();

    @Override
    public Server select(List<Server> servers) {
        if (servers == null || servers.isEmpty()) return null;

        Server best = null;
        int minConn = Integer.MAX_VALUE;

        for (Server server : servers) {
            int conn = connectionCounts.computeIfAbsent(server, k -> new AtomicInteger(0)).get();
            if (conn < minConn) {
                minConn = conn;
                best = server;
            }
        }

        // 模拟增加连接（实际使用需配合请求完成后的 decrement）
        if (best != null) {
            connectionCounts.get(best).incrementAndGet();
        }

        return best;
    }

    // 供外部调用：请求完成后减少连接数
    public void release(Server server) {
        AtomicInteger count = connectionCounts.get(server);
        if (count != null) {
            count.decrementAndGet();
        }
    }
}

适用于长连接或处理时间差异大的场景

需要维护连接状态，有额外开销

6. 源地址哈希（IP Hash / Source Hash）

根据客户端 IP（或其他唯一标识）做哈希，保证同一客户端始终路由到同一节点。

public class SourceHashLoadBalancer implements LoadBalancer {
    private String source; // 可通过构造函数传入 client IP

    public SourceHashLoadBalancer(String source) {
        this.source = source;
    }

    @Override
    public Server select(List<Server> servers) {
        if (servers == null || servers.isEmpty() || source == null) return null;
        int hash = source.hashCode();
        int index = (hash & 0x7FFFFFFF) % servers.size(); // 避免负数
        return servers.get(index);
    }
}

优点：会话保持（Session Stickiness）

缺点：节点增减会导致大量映射失效（可改用一致性哈希）

7. 一致性哈希（Consistent Hashing）

解决普通哈希在节点动态变化时缓存/会话大量失效的问题。

public class ConsistentHashingLoadBalancer implements LoadBalancer {
    private final SortedMap<Integer, Server> circle = new TreeMap<>();
    private final int virtualNodes; // 虚拟节点数

    public ConsistentHashingLoadBalancer(int virtualNodes) {
        this.virtualNodes = virtualNodes;
    }

    public void addServer(Server server) {
        for (int i = 0; i < virtualNodes; i++) {
            int hash = hash(server.getHost() + ":" + server.getPort() + "#" + i);
            circle.put(hash, server);
        }
    }

    public void removeServer(Server server) {
        for (int i = 0; i < virtualNodes; i++) {
            int hash = hash(server.getHost() + ":" + server.getPort() + "#" + i);
            circle.remove(hash);
        }
    }

    private int hash(String key) {
        return key.hashCode(); // 简化，生产建议用 MD5 或 MurmurHash
    }

    @Override
    public Server select(List<Server> servers) {
        if (circle.isEmpty()) {
            // 动态构建环（实际应提前构建）
            servers.forEach(this::addServer);
        }
        if (circle.isEmpty()) return null;

        // 假设 source 为请求 ID 或 IP
        String requestKey = "request_" + System.nanoTime(); // 实际应由调用方提供
        int hash = hash(requestKey);

        if (!circle.containsKey(hash)) {
            SortedMap<Integer, Server> tailMap = circle.tailMap(hash);
            hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        }
        return circle.get(hash);
    }
}

节点增减只影响局部数据

广泛用于缓存、分布式存储系统

总结对比

算法是否考虑权重是否有状态适用场景
随机❌❌简单快速分发
轮询❌✅（位置）请求均匀、节点同质
加权轮询✅✅节点性能不同
平滑加权轮询✅✅更公平的加权分发
最少连接❌（但看负载）✅长连接、异构任务
源地址哈希❌❌会话保持
一致性哈希❌（可扩展支持）✅（哈希环）缓存、分布式存储

结语

通过手写这七种负载均衡算法，我们不仅掌握了其实现细节，也理解了它们各自的优劣和适用边界。在真实项目中，可根据业务需求灵活选择或组合使用（例如：先一致性哈希定位节点组，再在组内轮询）。

提示：生产环境建议使用成熟组件（如 Ribbon、Spring Cloud LoadBalancer、Nginx、LVS），但理解底层原理永远是工程师的核心竞争力。

以上就是从零带你手写Java七种负载均衡算法实现方案的详细内容，更多关于Java负载均衡算法的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • SpringBoot Service和Dao的编写详解

    SpringBoot Service和Dao的编写详解

    这篇文章主要介绍了SpringBoot Service和Dao的编写详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-11-11
  • java实用验证码的实现代码

    java实用验证码的实现代码

    这篇文章主要为大家介绍了java实用验证码的实现代码，验证码实际上就是随机选择一些字符以图片的形式展现在页面上，感兴趣的小伙伴们可以参考一下
    2016-03-03
  • IDEA 2023 spring项目配置Maven全过程

    IDEA 2023 spring项目配置Maven全过程

    在IDEA中配置Maven需依次打开设置,搜索并配置Maven,成功时显示BUILD SUCCESS,此方法实用,供开发者参考,欢迎支持脚本之家
    2025-09-09
  • Java稀疏数组的应用实践

    Java稀疏数组的应用实践

    本文主要介绍了Java稀疏数组的应用实践，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2023-06-06
  • Java读取文本文件的各种方法

    Java读取文本文件的各种方法

    这篇文章主要介绍了Java读取文本文件的各种方法，在 Java 中有多种方法可以读取纯文本文件，例如你可以使用FileReader、BufferedReader或Scanner来读取文本文件，感兴趣的小伙伴和小编一起进入文章了解更多内容吧，希望能帮助到大家
    2021-11-11
  • Java实现窗体程序显示日历表

    Java实现窗体程序显示日历表

    这篇文章主要为大家详细介绍了Java实现窗体程序显示日历表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-06-06
  • java对象的序列化和反序列化

    java对象的序列化和反序列化

    这篇文章主要为大家详细介绍了java对象的序列化和反序列化，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2016-11-11
  • 精通Java List 按字段提取对象

    精通Java List 按字段提取对象

    这篇文章主要介绍了精通Java List 按字段提取对象的相关资料,需要的朋友可以参考下
    2023-11-11
  • 如何基于springboot-admin实现后台监控

    如何基于springboot-admin实现后台监控

    这篇文章主要介绍了如何基于springboot-admin实现后台监控,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-04-04
  • SpringBoot2.0整合tk.mybatis异常解决

    SpringBoot2.0整合tk.mybatis异常解决

    本文主要介绍了SpringBoot2.0整合tk.mybatis异常，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2021-12-12

最新评论