负载均衡算法有哪些？负载均衡算法实现代码怎么写

负载均衡是分布式系统高并发、高可用的核心组件，其核心目标是将网络流量或计算任务均匀地分发到多个服务器节点上，从而提升系统的吞吐量、响应速度和容错能力。实现高效的负载均衡不仅需要理解基础算法逻辑，更需根据业务场景（如长连接、缓存一致性）选择加权轮询、最少连接或一致性哈希等策略，并配合健康检查机制。 以下将从基础到进阶,详细解析主流负载均衡算法的实现逻辑与代码构建。

基础轮询与随机算法

在服务器集群配置相同、处理能力一致的场景下，最简单的算法是轮询和随机，轮询算法按照请求到达的顺序，依次将请求分发到后端服务器，这种算法实现简单,但无法感知服务器的实时负载差异。

随机算法则是通过随机函数从服务器列表中选取一个节点，在请求量巨大的情况下，随机分布会趋向于均匀，这两种算法在服务器性能差异较大时，会导致性能较弱的服务器过载，而性能较强的服务器闲置，在实际生产环境中，通常需要引入“权重”概念。

进阶加权轮询算法

为了解决服务器异构问题，加权轮询算法应运而生，该算法根据服务器的配置（如CPU、内存）设置权重，权重越高，被选中的概率越大。但在实现上，简单的加权轮询可能导致连续多个请求被打到同一台高权重服务器上，造成瞬间流量突刺。

工业界通常采用平滑加权轮询，该算法在每一轮选择中，不仅考虑当前权重，还会动态调整“当前权重值”，确保高权重服务器不会连续霸占请求,而是按照比例穿插分发。

以下是平滑加权轮询的Python核心实现逻辑：

class SmoothWeightedRoundRobin:
    def __init__(self, servers):
        # servers格式: [{'addr': '192.168.1.1', 'weight': 4}, ...]
        self.servers = servers
        self.current_weights = {s['addr']: 0 for s in servers}
    def get_server(self):
        total_weight = sum(s['weight'] for s in self.servers)
        best_server = None
        max_current_weight = -1
        for server in self.servers:
            addr = server['addr']
            # current_weight = current_weight + effective_weight
            self.current_weights[addr] += server['weight']
            if self.current_weights[addr] > max_current_weight:
                max_current_weight = self.current_weights[addr]
                best_server = server
        # 被选中的服务器，current_weight 减去总权重
        if best_server:
            self.current_weights[best_server['addr']] -= total_weight
        return best_server['addr']

这段代码通过动态维护current_weights，确保了流量分配的平滑性,是Nginx等主流负载均衡器采用的标准策略。

动态最少连接算法

对于处理时间差异较大的业务（例如有的请求只需1ms，有的需要1s），轮询算法会导致长连接堆积在某一台服务器上。最少连接算法通过记录每个后端节点当前正在处理的活跃连接数，优先将新请求分发给活跃连接数最少的服务器。

这是一种动态感知负载的算法，能够更有效地利用系统资源，实现时，需要维护一个并发计数器，并在请求建立连接时加1，连接释放时减1，由于涉及并发修改,代码实现时必须使用线程安全的数据结构或锁机制。

一致性哈希算法

在分布式缓存或需要会话保持的场景中，普通的哈希取模算法会导致服务器增减时，绝大部分缓存键失效或会话丢失，引发“缓存雪崩”。一致性哈希算法通过将服务器节点和请求键哈希到同一个环上（通常为2^32），顺时针查找最近的节点，从而确保只有受影响的小部分数据需要迁移。

为了解决节点分布不均导致的数据倾斜问题，实现时通常会引入虚拟节点，即每个物理节点在环上映射成多个虚拟节点,从而让数据分布更加均匀。

一致性哈希的Python实现核心如下：

import hashlib
class ConsistentHash:
    def __init__(self, nodes=None, virtual_nodes=10):
        self.virtual_nodes = virtual_nodes
        self.ring = dict()
        self.sorted_keys = []
        if nodes:
            for node in nodes:
                self.add_node(node)
    def _hash(self, key):
        # 使用MD5哈希并取整
        return int(hashlib.md5(key.encode('utf-8')).hexdigest(), 16)
    def add_node(self, node):
        for i in range(self.virtual_nodes):
            virtual_key = f"{node}:{i}"
            key = self._hash(virtual_key)
            self.ring[key] = node
            self.sorted_keys.append(key)
        self.sorted_keys.sort()
    def get_node(self, key):
        if not self.ring:
            return None
        hash_key = self._hash(key)
        # 二分查找顺时针最近的节点
        for ring_key in self.sorted_keys:
            if ring_key >= hash_key:
                return self.ring[ring_key]
        # 环的末尾回到开头
        return self.ring[self.sorted_keys[0]]

工业级实现的专业建议

在代码落地时，仅仅实现算法逻辑是不够的。一个专业的负载均衡器必须具备健康检查和熔断机制。 如果后端服务出现故障或响应超时，负载均衡器必须能够自动将其剔除流量池，待服务恢复后再重新加入,这通常结合心跳检测和熔断器模式来实现。

建议采用策略模式设计代码架构，将上述算法封装为独立的策略类，通过配置文件动态切换算法，从而提升系统的扩展性和维护性，在性能敏感的场景下，应尽量减少锁的粒度,使用无锁编程或CAS操作来维护连接数计数器。

相关问答

Q1：加权轮询和最少连接算法分别适用于什么业务场景？
A： 加权轮询适用于请求处理时间大致相同，但服务器硬件配置存在差异的场景，如静态资源分发，最少连接算法则适用于请求处理时长波动剧烈的场景，如复杂的数据库查询或微服务调用,它能根据实时压力动态调整流量分配。

Q2：为什么一致性哈希算法需要引入虚拟节点？
A： 引入虚拟节点是为了解决数据倾斜问题，当物理节点数量较少时，简单的哈希可能导致大量请求落在同一个节点上，而其他节点空闲，通过将一个物理节点映射为多个虚拟节点，可以让数据在哈希环上分布得更均匀,从而平衡各节点的负载。

希望以上关于负载均衡算法的深度解析与代码实现能为您的架构设计提供有力参考，如果您在实际开发中遇到了特定的性能瓶颈，欢迎在评论区分享您的场景,我们可以共同探讨更优的解决方案。