C++实现高性能负载均衡算法（从零开始掌握轮询、加权轮询与最小连接数策略）

什么是负载均衡？

负载均衡就是将网络请求或任务分发到多个计算资源（如服务器）上，以避免单点过载，提高响应速度和系统稳定性。常见的应用场景包括Web服务器集群、微服务架构、数据库读写分离等。

1. 轮询算法（Round Robin）

这是最简单的轮询算法C++实现方式。它按顺序依次将请求分配给每个服务器，循环往复。

#include <iostream>#include <vector>#include <string>class RoundRobin {private:    std::vector<std::string> servers;    int currentIndex = 0;public:    RoundRobin(const std::vector<std::string>& servers) : servers(servers) {}    std::string getNextServer() {        if (servers.empty()) return "";        std::string server = servers[currentIndex];        currentIndex = (currentIndex + 1) % servers.size();        return server;    }};int main() {    std::vector<std::string> serverList = {"192.168.1.10", "192.168.1.11", "192.168.1.12"};    RoundRobin lb(serverList);    for (int i = 0; i < 6; ++i) {        std::cout << "Request " << i + 1 << " -> " << lb.getNextServer() << std::endl;    }    return 0;}

运行结果会依次输出：192.168.1.10 → 192.168.1.11 → 192.168.1.12 → 192.168.1.10...，实现公平轮询。

2. 加权轮询算法（Weighted Round Robin）

当服务器性能不同时，我们可以为每台服务器分配一个权重。性能强的服务器获得更高权重，处理更多请求。这就是加权轮询C++的核心思想。

#include <iostream>#include <vector>#include <string>class WeightedRoundRobin {private:    struct Server {        std::string ip;        int weight;        int currentWeight;        Server(const std::string& ip, int w) : ip(ip), weight(w), currentWeight(0) {}    };    std::vector<Server> servers;public:    void addServer(const std::string& ip, int weight) {        servers.emplace_back(ip, weight);    }    std::string getNextServer() {        if (servers.empty()) return "";        // 找出当前权重最大的服务器        int maxIndex = 0;        for (size_t i = 1; i < servers.size(); ++i) {            if (servers[i].currentWeight > servers[maxIndex].currentWeight) {                maxIndex = i;            }        }        std::string selected = servers[maxIndex].ip;        servers[maxIndex].currentWeight -= getTotalWeight();        // 所有服务器权重增加原始权重        for (auto& s : servers) {            s.currentWeight += s.weight;        }        return selected;    }private:    int getTotalWeight() {        int total = 0;        for (const auto& s : servers) {            total += s.weight;        }        return total;    }};int main() {    WeightedRoundRobin lb;    lb.addServer("192.168.1.10", 1);    lb.addServer("192.168.1.11", 2);    lb.addServer("192.168.1.12", 3);    for (int i = 0; i < 6; ++i) {        std::cout << "Request " << i + 1 << " -> " << lb.getNextServer() << std::endl;    }    return 0;}

在这个例子中，IP为 192.168.1.12 的服务器权重最高（3），因此它会比其他服务器接收更多请求，实现按性能分配负载。

3. 最小连接数算法（Least Connections）

该算法总是将新请求分配给当前活跃连接数最少的服务器。这需要实时跟踪每台服务器的连接状态，适用于连接持续时间差异较大的场景。

#include <iostream>#include <vector>#include <string>#include <algorithm>class LeastConnections {private:    struct Server {        std::string ip;        int activeConnections;        Server(const std::string& ip) : ip(ip), activeConnections(0) {}    };    std::vector<Server> servers;public:    void addServer(const std::string& ip) {        servers.emplace_back(ip);    }    std::string getNextServer() {        if (servers.empty()) return "";        auto minIt = std::min_element(servers.begin(), servers.end(),            [](const Server& a, const Server& b) {                return a.activeConnections < b.activeConnections;            });        minIt->activeConnections++;        return minIt->ip;    }    void releaseConnection(const std::string& ip) {        for (auto& s : servers) {            if (s.ip == ip) {                if (s.activeConnections > 0) s.activeConnections--;                break;            }        }    }};int main() {    LeastConnections lb;    lb.addServer("192.168.1.10");    lb.addServer("192.168.1.11");    lb.addServer("192.168.1.12");    for (int i = 0; i < 5; ++i) {        std::cout << "Assign Request " << i + 1 << " to " << lb.getNextServer() << std::endl;    }    // 模拟释放一个连接    lb.releaseConnection("192.168.1.10");    std::cout << "After releasing one connection from 192.168.1.10:" << std::endl;    std::cout << "Next request goes to: " << lb.getNextServer() << std::endl;    return 0;}

这种最小连接数算法C++实现能动态感知服务器负载，适合长连接或高并发场景。

总结

通过本文，你已经掌握了三种核心的C++负载均衡算法：

• 轮询算法C++：简单公平，适用于同构服务器集群。
• 加权轮询C++：根据服务器性能分配请求，更智能。
• 最小连接数算法C++：动态感知负载，适合复杂业务场景。

在实际项目中，你可以根据业务需求选择合适策略，甚至结合多种算法构建混合负载均衡器。希望这篇教程能为你打下坚实基础！

关键词：C++负载均衡算法、轮询算法C++、加权轮询C++、最小连接数算法C++