负载均衡是分布式系统中提升性能和可用性的关键技术。轮询（Round Robin）作为一种基础负载均衡算法，以其简单高效的特点广泛应用于服务器性能相近的场景。本文将介绍如何利用 Java 的 AtomicInteger 实现一个线程安全的轮询负载均衡器，并结合小八超市的业务场景，展示其在实际测试中的应用。

轮询负载均衡

轮询负载均衡算法将传入的请求按顺序依次分配到服务器列表中的每个服务器，循环往复。这种方式实现简单，能有效分散请求压力，特别适合服务器性能较为均衡的场景。例如，在小八超市的商品查询系统中，多个后端节点处理用户请求，轮询算法可确保请求均匀分配，避免单点过载。

特点与优势

循环负载均衡是一种简单高效的请求分发策略，它通过将请求按顺序轮流分配给服务器，确保了每台服务器承担的请求数量大致相同，从而实现了均衡的负载分布。例如，在拥有 4 台服务器的系统中，请求会依次由 Server1 到 Server4 依次处理，然后重新从 Server1 开始循环，适用于请求量较为稳定、服务器能力相近的场景。其调度逻辑清晰、行为可预测，非常利于问题排查和系统监控，尤其适合对请求顺序有要求或希望避免某台服务器长时间空闲的系统环境。同时，该算法实现简单，不需要维护服务器权重或进行复杂计算，降低了开发与运维成本，非常适合用于自动化测试平台、接口模拟系统或混沌工程实验等测试场景中的快速部署和验证任务。

局限性

尽管循环负载均衡具有实现简单、分发均衡的优点，但它也存在一些局限性。首先，它无法感知服务器的实时负载状态，默认所有服务器处理能力相同，可能导致性能较弱的节点频繁被分配请求而发生过载，进而拖慢整体响应速度。其次，在服务器资源和性能不均（异构环境）的系统中，轮询策略仍按固定顺序分配请求，无法根据节点能力动态调整分发策略，可能造成高性能节点空闲而低性能节点拥堵，影响系统整体吞吐率。此外，该算法缺乏故障感知能力，无法识别和剔除已宕机或不可用的节点，需要额外引入健康检查机制以保证请求不会被分配到故障服务器。因此，在复杂生产环境中，循环调度更适合作为基础策略，结合其他机制以增强其健壮性与智能性。

为什么使用 AtomicInteger

在多线程环境下，轮询算法需要维护一个共享索引来确定下一个分配的服务器。传统的索引更新（如 index++）在并发场景下会引发线程安全问题，可能导致请求分配错误或数据竞争。

Java 的 AtomicInteger（位于 java.util.concurrent.atomic 包）提供无锁的原子操作，通过 CAS（Compare-And-Swap）机制确保线程安全。getAndUpdate 方法能原子性地获取当前值并更新，完美适用于轮询索引的维护，避免了显式加锁的性能开销。例如，在高并发场景下，AtomicInteger 能确保多个线程安全地按顺序分配请求到服务器。

Show You Code

以下是一个使用 AtomicInteger 实现的线程安全轮询负载均衡器，适用于小八超市的商品查询场景：

package org.funtester.performance.books.chapter05.section6;

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * FunTester 轮询负载均衡器示例
 */
public class LoadBalancerDemo {

    private final List<String> servers; // 服务器列表
    private final AtomicInteger currentIndex; // 当前索引

    /**
     * 构造函数，初始化服务器列表
     * @param servers 服务器地址列表
     */
    public LoadBalancerDemo(List<String> servers) {
        if (servers == null || servers.isEmpty()) {
            throw new IllegalArgumentException("FunTester: 服务器列表不能为空");
        }
        this.servers = servers;
        this.currentIndex = new AtomicInteger(0);
    }

    /**
     * 线程安全地获取下一个服务器
     * @return 服务器地址
     */
    public String getServer() {
        int index = currentIndex.getAndUpdate(i -> (i + 1) % servers.size());
        return servers.get(index);
    }

    public static void main(String[] args) {
        List<String> serverList = List.of("Server1:8081", "Server2:8082", "Server3:8083", "Server4:8084");
        LoadBalancerDemo loadBalancer = new LoadBalancerDemo(serverList);

        System.out.println("FunTester: 模拟轮询负载均衡器");
        for (int i = 0; i < 10; i++) {
            System.out.println("请求 " + (i + 1) + " 分配至: " + loadBalancer.getServer());
        }
    }
}

代码解读：

服务器列表：servers 存储后端节点地址，如 "Server1:8081"，可替换为实际 IP 和端口。
索引管理：AtomicInteger 的 getAndUpdate 方法原子性地获取当前索引并递增，使用模运算（% servers.size()）实现循环分配。
异常处理：构造函数检查服务器列表是否为空，防止无效配置。
输出示例：

FunTester: 模拟轮询负载均衡器
请求 1 分配至: Server1:8081
请求 2 分配至: Server2:8082
请求 3 分配至: Server3:8083
请求 4 分配至: Server4:8084
请求 5 分配至: Server1:8081
...

在小八超市场景中，假设 4 个后端节点处理 WebSocket 商品查询请求，负载均衡器可确保请求均匀分配到各节点，降低单点压力。测试时，可通过日志验证分配顺序是否正确。

多线程环境模拟

为验证负载均衡器在高并发场景下的表现，使用 ExecutorService 模拟多个线程并发请求：

package org.funtester.performance.books.chapter05.section6;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * FunTester 轮询负载均衡器多线程测试
 */
public class RoundRobinLoadBalancer {

    private final List<String> servers;
    private final AtomicInteger currentIndex;

    /**
     * 构造函数，初始化服务器列表
     * @param servers 服务器地址列表
     */
    public RoundRobinLoadBalancer(List<String> servers) {
        if (servers == null || servers.isEmpty()) {
            throw new IllegalArgumentException("FunTester: 服务器列表不能为空");
        }
        this.servers = servers;
        this.currentIndex = new AtomicInteger(0);
    }

    /**
     * 线程安全地获取下一个服务器
     * @return 服务器地址
     */
    public String getServer() {
        int index = currentIndex.getAndUpdate(i -> (i + 1) % servers.size());
        return servers.get(index);
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        List<String> serverList = List.of("Server1:8081", "Server2:8082", "Server3:8083", "Server4:8084");
        RoundRobinLoadBalancer loadBalancer = new RoundRobinLoadBalancer(serverList);

        ExecutorService executor = Executors.newFixedThreadPool(4); // 创建 4 个线程
        List<Future<String>> futures = new ArrayList<>();

        // 提交 10 个并发请求
        for (int i = 0; i < 10; i++) {
            futures.add(executor.submit(loadBalancer::getServer));
        }

        // 收集并打印结果
        for (int i = 0; i < futures.size(); i++) {
            System.out.println("请求 " + (i + 1) + " 分配至: " + futures.get(i).get());
        }

        executor.shutdown(); // 关闭线程池
    }
}

代码解读：

线程池：使用 Executors.newFixedThreadPool(4) 创建 4 个线程，模拟并发请求。
异步提交：通过 submit 方法提交任务，getServer 方法确保线程安全分配。
结果收集：Future 对象获取分配结果，输出可能因线程调度而顺序不同，但分配仍遵循轮询规则。

输出示例：

请求 1 分配至: Server1:8081
请求 2 分配至: Server2:8082
请求 3 分配至: Server3:8083
请求 4 分配至: Server4:8084
请求 5 分配至: Server1:8081
...

在小八超市的高并发场景中，假设 1000 个用户同时查询商品价格，负载均衡器可确保请求均匀分配到 4 个后端节点。通过日志分析分配比例，验证是否接近 25%（1000 ÷ 4 ≈ 250 请求/节点）。若某节点响应缓慢，可结合 MockServer 模拟延迟，测试负载均衡器的表现。

优化与扩展

为提升轮询负载均衡器的实用性，可考虑以下优化：

健康检查：定期检测服务器状态，剔除故障节点。例如，使用 HTTP 探针检查节点是否可用。
加权轮询：为性能较强的服务器分配更多请求。例如，Server1 处理能力是 Server2 的两倍，可设置权重 2:1。
动态更新：支持运行时添加或移除服务器节点。例如，小八超市新增节点时，动态更新 servers 列表。
延迟统计：记录每个节点的响应时间，优化分配策略。例如，优先分配到响应快的节点。

在小八超市的商品查询场景中，可将负载均衡器集成到客户端或网关层，结合 MockServer 模拟后端节点响应。例如：

配置 MockServer 模拟 4 个后端节点，分别返回正常响应、库存不足和超时。
使用负载均衡器分发请求，验证分配均匀性和系统对异常响应的处理。
通过多线程测试，模拟高峰期 1000 用户并发查询，分析 TPS 和响应时间。

总结发言

通过 AtomicInteger 实现的轮询负载均衡器结构简洁、性能高效，借助 CAS 机制确保线程安全，适合高并发场景。在小八超市的商品查询测试中，该负载均衡器能有效分散请求压力，提升系统稳定性。通过结合 MockServer 和多线程测试，可进一步验证其在复杂场景下的表现。未来可通过健康检查和加权轮询等优化，满足更复杂的分布式系统需求，为微服务架构和性能测试提供有力支持。

FunTester 原创精华

从 Java 开始性能测试

故障测试与 Web 前端

服务端功能测试

性能测试专题

Java、Groovy、Go

测试开发、自动化、单测&白盒

测试理论、FunTester 风采

视频专题

↙↙↙阅读原文可查看相关链接，并与作者交流