图解六种常见负载均衡算法，一看就懂！

负载均衡是分布式系统中提升性能和可靠性的核心技术，通过将请求分散到多个服务器，避免单点过载。本文将通过图解和代码示例，深入解析六种常见负载均衡算法的原理、适用场景及实现逻辑，帮助开发者快速掌握并应用。

一、轮询（Round Robin）

原理与图解

轮询算法按顺序将请求依次分配给服务器列表中的每个节点，循环往复。例如，有三台服务器S1、S2、S3，请求分配顺序为S1→S2→S3→S1→S2→S3……

代码实现（Python）

servers = ["S1", "S2", "S3"]
index = 0
def round_robin():
    global index
    server = servers[index % len(servers)]
    index += 1
    return server
# 测试
for _ in range(6):
    print(round_robin())  # 输出顺序：S1, S2, S3, S1, S2, S3

适用场景

• 服务器性能相近
• 请求处理时间相对均衡
• 简单易实现的入门级场景

二、加权轮询（Weighted Round Robin）

原理与图解

在轮询基础上，为服务器分配权重值，权重高的服务器接收更多请求。例如，S1权重2，S2权重1，S3权重1，则分配顺序为S1→S1→S2→S3→S1→S2→S3……

代码实现

servers = [
    {"name": "S1", "weight": 2},
    {"name": "S2", "weight": 1},
    {"name": "S3", "weight": 1}
]
current_weight = 0
def weighted_round_robin():
    global current_weight
    # 选择当前权重最大的服务器
    selected = None
    max_weight = -1
    for server in servers:
        if server["weight"] > max_weight:
            max_weight = server["weight"]
            selected = server
    # 更新权重（临时减1，下次循环恢复）
    selected["weight"] -= 1
    current_weight = max_weight
    return selected["name"]
# 初始化权重
for server in servers:
    server["weight"] = server["weight"]  # 重置权重
# 测试
for _ in range(6):
    print(weighted_round_robin())  # 输出顺序：S1, S1, S2, S3, S1, S2

适用场景

• 服务器性能差异明显（如CPU核心数不同）
• 需要按能力分配流量的场景

三、随机（Random）

原理与图解

随机算法从服务器列表中随机选择一个节点处理请求，每个节点被选中的概率均等。

代码实现

import random
servers = ["S1", "S2", "S3"]
def random_algorithm():
    return random.choice(servers)
# 测试
for _ in range(6):
    print(random_algorithm())  # 输出结果随机，如S2, S1, S3, S1, S3, S2

适用场景

• 请求处理时间短且均匀
• 服务器性能相近的简单场景
• 作为其他算法的补充或基准对比

四、加权随机（Weighted Random）

原理与图解

在随机算法基础上，根据服务器权重调整选中概率。例如，S1权重2，S2权重1，S3权重1，则S1被选中的概率为50%，S2和S3各25%。

代码实现

import random
servers = [
    {"name": "S1", "weight": 2},
    {"name": "S2", "weight": 1},
    {"name": "S3", "weight": 1}
]
def weighted_random():
    total_weight = sum(server["weight"] for server in servers)
    r = random.uniform(0, total_weight)
    upto = 0
    for server in servers:
        if upto + server["weight"] >= r:
            return server["name"]
        upto += server["weight"]
    return servers[-1]["name"]  # 防止浮点误差
# 测试
results = {"S1": 0, "S2": 0, "S3": 0}
for _ in range(10000):
    selected = weighted_random()
    results[selected] += 1
print(results)  # 输出接近S1:5000, S2:2500, S3:2500

适用场景

• 服务器性能差异明显
• 需要概率性分配流量的场景（如A/B测试）

五、最小连接数（Least Connections）

原理与图解

动态选择当前连接数最少的服务器，适用于长连接场景（如WebSocket）。例如，S1有2个连接，S2有1个，S3有3个，则新请求分配给S2。

代码实现

servers = [
    {"name": "S1", "connections": 2},
    {"name": "S2", "connections": 1},
    {"name": "S3", "connections": 3}
]
def least_connections():
    return min(servers, key=lambda x: x["connections"])["name"]
# 测试
print(least_connections())  # 输出：S2

适用场景

• 长连接服务（如游戏服务器、实时通信）
• 请求处理时间差异大的场景
• 需要动态平衡负载的场景

六、源地址哈希（IP Hash）

原理与图解

根据客户端IP地址计算哈希值，将同一IP的请求固定分配到同一服务器，实现会话保持（Session Sticky）。

代码实现

def ip_hash(ip):
    # 简化版哈希计算（实际需更复杂的算法）
    hash_value = sum(ord(c) for c in ip) % 3
    servers = ["S1", "S2", "S3"]
    return servers[hash_value]
# 测试
print(ip_hash("192.168.1.1"))  # 输出固定值（如S1）
print(ip_hash("10.0.0.2"))     # 输出另一固定值（如S2）

适用场景

• 需要会话保持的场景（如电商购物车）
• 客户端IP分布均匀的场景
• 避免会话迁移的开销

算法对比与选型建议

算法	优点	缺点	适用场景
轮询	实现简单，公平分配	无法处理服务器差异	性能相近的服务器集群
加权轮询	按能力分配流量	权重调整需重启服务	性能差异明显的服务器
随机	防止请求集中	无法保证均衡	短请求、简单场景
加权随机	概率性分配流量	实现复杂	A/B测试、性能差异场景
最小连接数	动态平衡负载	需维护连接数状态	长连接、动态负载场景
源地址哈希	实现会话保持	服务器增减时大量重定向	需要粘滞会话的场景

实践建议

1. 短请求场景：优先选择轮询或随机算法，实现简单且开销低。
2. 长连接场景：使用最小连接数算法，避免单台服务器过载。
3. 性能差异场景：采用加权轮询或加权随机，按能力分配流量。
4. 会话保持场景：使用源地址哈希，但需注意服务器增减时的会话迁移问题。
5. 动态调整：结合监控系统，根据实时负载动态切换算法（如从轮询切换到最小连接数）。

通过理解这六种算法的原理和适用场景，开发者可以更合理地设计负载均衡策略，提升系统的性能和可靠性。