负载均衡算法对比

之前一直用老方案，最近换了新方法确实方便不少。对比一下两种做法，给还在犹豫的朋友一个参考。

先搞清楚原理

负载均衡的底层原理涉及边界条件。用代码演示比画图更直观：

def binary_search(arr: list, target: int) -> int:
    left, right = 0, len(arr) - 1
    comparisons = 0
    while left <= right:
        mid = (left + right) // 2
        comparisons += 1
        if arr[mid] == target:
            return mid, comparisons
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1, comparisons

import random
data = sorted(random.sample(range(100000), 10000))
target = data[len(data) // 2]
idx, comps = binary_search(data, target)
print(f'找到索引: {idx}, 比较次数: {comps}, 理论log2(n): {len(data).bit_length()}')

实际怎么用

实际用的时候有几个注意点。首先是配置问题，不同环境参数可能不一样。其次是性能，数据量大的时候要注意边界条件。看这段实际运行的代码：

class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {}
        self.order = []

    def get(self, key: str):
        if key in self.cache:
            self.order.remove(key)
            self.order.append(key)
            return self.cache[key]
        return -1

    def put(self, key: str, value):
        if key in self.cache:
            self.order.remove(key)
        elif len(self.cache) >= self.capacity:
            oldest = self.order.pop(0)
            del self.cache[oldest]
        self.cache[key] = value
        self.order.append(key)

cache = LRUCache(3)
pages = [1, 2, 3, 1, 4, 1, 5, 3]
hits, misses = 0, 0
for page in pages:
    if cache.get(page) != -1:
        hits += 1
    else:
        misses += 1
        cache.put(page, f'data_{page}')
print(f'命中率: {hits/(hits+misses)*100:.1f}%')

进阶一点的用法

有些场景下负载均衡的常规写法不够用，需要做边界条件。这个改动涉及的地方不多，但要注意顺序：

容易踩的坑

说几个容易踩的坑。第一个是边界条件的问题，很多人在这上面栽过跟头。第二个是版本兼容性，不同版本行为可能不一样。第三个是边界情况，空值和异常输入要处理好。

写在最后

总结一下，负载均衡的关键在于状态机与协议。掌握了这个，其他用法都是在这个基础上扩展。建议多写几个小demo练手，光看不动手容易忘。