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

负载均衡是分布式系统架构中的核心组件，通过合理分配请求流量，能够显著提升系统的可用性、扩展性和性能。本文将通过图解方式，结合实际场景与代码示例，深入解析六种常见负载均衡算法的原理、适用场景及实现细节。

一、轮询算法（Round Robin）

1. 原理图解

轮询算法将请求按顺序依次分配给后端服务器，形成“循环队列”。例如，三台服务器S1、S2、S3的分配顺序为：S1→S2→S3→S1→S2→S3……

2. 代码实现（Python示例）

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

3. 适用场景与优缺点

• 优点：实现简单，流量分配均匀。
• 缺点：未考虑服务器性能差异，可能导致性能弱的服务器过载。
• 典型场景：后端服务器性能相近的Web服务。

二、加权轮询算法（Weighted Round Robin）

1. 原理图解

为不同性能的服务器分配权重（如S1:3，S2:2，S3:1），按权重比例分配请求。例如，每6次请求中，S1分配3次，S2分配2次，S3分配1次。

2. 代码实现

servers = [
    {"name": "S1", "weight": 3},
    {"name": "S2", "weight": 2},
    {"name": "S3", "weight": 1}
]
current_weights = [server["weight"] for server in servers]
total_weight = sum(server["weight"] for server in servers)
def weighted_round_robin():
    max_weight = max(current_weights)
    selected_server = None
    for i, server in enumerate(servers):
        if current_weights[i] == max_weight:
            selected_server = server["name"]
            current_weights[i] = 0
            break
    # 更新权重（简化版：每次请求后所有权重+1）
    for i in range(len(current_weights)):
        if i != selected_server_index:  # 实际需记录选中索引
            current_weights[i] += 1
    return selected_server
# 更高效的实现需维护动态权重，此处简化逻辑

3. 适用场景与优缺点

• 优点：兼顾服务器性能差异，资源利用率高。
• 缺点：实现复杂度略高于轮询。
• 典型场景：服务器性能不均的集群（如CPU核心数不同）。

三、随机算法（Random）

1. 原理图解

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

2. 代码实现

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

3. 适用场景与优缺点

• 优点：实现简单，适用于请求分布均匀的场景。
• 缺点：无法保证流量分配的绝对均衡。
• 典型场景：短连接、无状态服务（如静态资源服务器）。

四、加权随机算法（Weighted Random）

1. 原理图解

根据服务器权重随机选择，权重高的服务器被选中的概率更大。例如，S1:60%，S2:30%，S3:10%。

2. 代码实现

import random
servers = [
    {"name": "S1", "weight": 60},
    {"name": "S2", "weight": 30},
    {"name": "S3", "weight": 10}
]
def weighted_random():
    total = sum(server["weight"] for server in servers)
    r = random.uniform(0, total)
    upto = 0
    for server in servers:
        if upto + server["weight"] >= r:
            return server["name"]
        upto += server["weight"]
# 测试
results = [weighted_random() for _ in range(100)]
print({k: results.count(k)/100 for k in ["S1", "S2", "S3"]})  # 输出接近权重比例

3. 适用场景与优缺点

• 优点：兼顾随机性与服务器性能差异。
• 缺点：需维护权重数据，实现稍复杂。
• 典型场景：广告投放、推荐系统等需要概率控制的场景。

五、最少连接算法（Least Connections）

1. 原理图解

动态统计每台服务器的当前连接数，将新请求分配给连接数最少的服务器。

2. 代码实现

servers = {
    "S1": {"connections": 0},
    "S2": {"connections": 0},
    "S3": {"connections": 0}
}
def least_connections():
    return min(servers.items(), key=lambda x: x[1]["connections"])[0]
# 模拟请求处理
def handle_request(server_name):
    servers[server_name]["connections"] += 1
    # 模拟处理完成
    # servers[server_name]["connections"] -= 1  # 实际需在请求完成后减少
# 测试
for _ in range(10):
    server = least_connections()
    handle_request(server)
    print(f"Allocated to {server}, Connections: {servers}")

3. 适用场景与优缺点

• 优点：动态适应负载变化，避免过载。
• 缺点：需维护连接数状态，增加系统开销。
• 典型场景：长连接服务（如数据库、WebSocket）。

六、源地址哈希算法（Source Hash）

1. 原理图解

根据客户端IP或请求ID的哈希值，将同一客户端的请求始终路由到同一台服务器（一致性哈希）。

2. 代码实现

import hashlib
servers = ["S1", "S2", "S3"]
def source_hash(client_ip):
    hash_value = int(hashlib.md5(client_ip.encode()).hexdigest(), 16)
    return servers[hash_value % len(servers)]
# 测试
print(source_hash("192.168.1.1"))  # 固定输出某台服务器

3. 适用场景与优缺点

• 优点：保证同一客户端的请求由同一服务器处理，适用于会话保持。
• 缺点：服务器增减时需重新哈希，可能导致大量请求重定向。
• 典型场景：需要状态保持的服务（如购物车、登录会话）。

七、算法对比与选型建议

算法	复杂度	均衡性	适用场景
轮询	低	中	服务器性能相近
加权轮询	中	高	服务器性能不均
随机	低	低	短连接、无状态服务
加权随机	中	中高	需要概率控制的场景
最少连接	高	高	长连接、动态负载场景
源地址哈希	中	中	需要会话保持的场景

选型建议：

1. 静态分配：优先选择轮询或加权轮询。
2. 动态负载：选择最少连接算法。
3. 会话保持：选择源地址哈希算法。
4. 概率控制：选择加权随机算法。

八、总结

负载均衡算法的选择需结合业务场景、服务器性能和系统需求。轮询和随机算法适用于简单场景，加权算法可优化资源利用率，最少连接算法适合动态负载，源地址哈希算法则解决会话保持问题。实际部署时，可结合多种算法（如Nginx的ip_hash与least_conn混合使用）以达到最佳效果。

通过理解这些算法的原理与实现细节，开发者能够更高效地设计分布式系统架构，提升系统的可靠性与性能。