Java 负载均衡的 5 种算法实现原理

什么是负载均衡(Load Balancing)

负载均衡是指将流量合理分配到多台服务器上，以避免单个服务器负荷过大无法正常工作，从而提高系统的可用性和性能。

负载均衡的算法类型

1. 随机算法(RANDOM)
2. 轮询算法(ROUND ROBIN)
3. 哈希算法(HASH)
4. 加权轮询算法(WEIGHTED ROUND ROBIN)
5. 加权随机算法(WEIGHTED RANDOM)

随机算法(RANDOM)

随机性比较强，根据系统运行时随机分配请求给不同的服务器，通常适用于服务器性能相近，或者只是需要随机访问服务器的场景。但是在实际应用时，容易出现不均衡的现象。

示例：使用随机算法实现负载均衡

public class RandomLoadBalance implements LoadBalance {
    @Override
    public String select(List<String> providers) {
        Random random = new Random();
        int index = random.nextInt(providers.size());
        return providers.get(index);
    }
}

轮询算法(ROUND ROBIN)

轮询算法是按照顺序依次把请求分配给不同的服务器，每个服务器平均分配请求。在负载比较均衡的情况下，这是一种比较不错的算法。但是当某个服务器负载变大，轮询算法就会产生不均衡情况。

示例：使用轮询算法实现负载均衡

public class RoundRobinLoadBalance implements LoadBalance {

    private AtomicInteger counter = new AtomicInteger(0);

    @Override
    public String select(List<String> providers) {
        int index = counter.getAndIncrement() % providers.size();
        return providers.get(index);
    }
}

哈希算法(HASH)

哈希算法通过将客户端的请求使用哈希函数转换为一个哈希值，然后再通过这个哈希值与服务器列表中的服务器进行匹配，从而实现请求负载均衡。稳定性很好，在服务不变的情况下，同一客户端的请求总是会被分配到相同的服务器上，适用于需要保持会话一致性的场景，比如分布式存储系统、缓存系统等。

示例：使用哈希算法实现负载均衡

public class HashLoadBalance implements LoadBalance {

    @Override
    public String select(List<String> providers, String clientIp) {
        int hashCode = clientIp.hashCode();
        int index = hashCode % providers.size();
        return providers.get(index);
    }
}

加权轮询算法(WEIGHTED ROUND ROBIN)

加权轮询算法的思想是根据服务器权重不同，不同的服务器获取的请求数量也会有所不同。加权轮询算法主要用于服务器性能不同的情况下，会根据性能好的服务器分配更多的请求。

示例：使用加权轮询算法实现负载均衡

public class WeightedRoundRobinLoadBalance implements LoadBalance {

    private AtomicInteger position = new AtomicInteger(0);

    @Override
    public String select(List<String> providers) {
        int[] weights = {3, 2, 1};
        int maxWeight = Arrays.stream(weights).max().orElse(0);

        while (true) {
            int index = position.getAndIncrement() % providers.size();
            if (position.get() > Integer.MAX_VALUE - 10000) {
                position.set(0);
            }
            if (index == 0) {
                maxWeight = Arrays.stream(weights).max().orElse(0);
            }
            if (weights[index] >= maxWeight) {
                return providers.get(index);
            }
        }
    }
}

加权随机算法(WEIGHTED RANDOM)

加权随机算法与加权轮询算法类似，只不过不是按顺序进行分配，而是通过随机数实现。适用于需要按照比例分配请求的场景，比如电商系统中，根据商品的销售量和库存情况将请求分配给不同的服务器。

示例：使用加权随机算法实现负载均衡

public class WeightedRandomLoadBalance implements LoadBalance {

    @Override
    public String select(List<String> providers) {
        int[] weights = {3, 2, 1};
        int sum = Arrays.stream(weights).sum();
        int rand = new Random().nextInt(sum) + 1;

        for (int i = 0; i < weights.length; i++) {
            if (rand <= weights[i]) {
                return providers.get(i);
            }
            rand -= weights[i];
        }
        return providers.get(0);
    }
}

总结

不同的负载均衡算法适用于不同的业务场景，在使用时需要根据实际情况进行选择。除了上述 5 种常见负载均衡算法之外，还有一些算法可以尝试，比如最小连接数算法、加权最小连接数算法等。在实际场景中，也有可能需要根据业务需求自行设计负载均衡算法，以达到更好的效果。