这5种负载均衡算法，建议掌握！

发表于 更新于 分类于 阅读次数： 本文字数： 9.5k 阅读时长 ≈ 9 分钟

大家好呀，我是猿java。

在分布式系统中，负载均衡（Load Balancing）扮演着至关重要的角色。它不仅能提高系统的可用性和稳定性，还能有效分配资源，提升用户体验。那么，负载均衡有哪些算法呢？它们的性能有什么差异？这篇文章，我们来一起分析。

1. 什么是负载均衡？

负载均衡是一种技术，通过将请求或任务分配到多个服务器或资源上，以达到优化资源使用、最大化吞吐量、减少响应时间以及避免任何单一资源过载的目的。简单来说，负载均衡就像一个交通信号灯，合理地指挥流量，确保每条路都有序通行。

2. 负载均衡的作用

  1. 提高可用性和可靠性：通过多台服务器分担压力，即使部分服务器宕机，系统仍能正常运行。
  2. 优化资源利用：合理分配请求，避免某些服务器过载而其他服务器闲置。
  3. 提升响应速度：将请求分配到最合适的服务器，缩短响应时间，提高用户体验。
  4. 扩展系统容量：随着业务增长，可以通过增加服务器来扩展系统的处理能力。

3. 负载均衡算法分析

负载均衡算法决定了请求如何在多个服务器之间分配，常见的负载均衡算法主要包括以下 5种：

  1. 轮询（Round Robin）
  2. 加权轮询（Weighted Round Robin）
  3. 最少连接数（Least Connections）
  4. 哈希（Hash-based）
  5. 随机（Random）

下面，我们将逐一分析这些算法的原理，并结合Java源码进行深入解析。

3.1 轮询

轮询（Round Robin）是一种最简单也是最常用的负载均衡算法。它按照顺序将每个请求依次分配给列表中的每个服务器。当到达列表末尾时，再从头开始。这种方式简单、公平，适用于服务器性能相近的场景。

以下是一个Java实现的轮询算法示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class RoundRobinLoadBalancer<T> {
    private final List<T> servers;
    private AtomicInteger index;

    public RoundRobinLoadBalancer(List<T> servers) {
        this.servers = servers;
        this.index = new AtomicInteger(0);
    }

    public T select() {
        if (servers.isEmpty()) {
            return null;
        }
        int currentIndex = Math.abs(index.getAndIncrement() % servers.size());
        return servers.get(currentIndex);
    }
}

解析：

  • 使用AtomicInteger确保在多线程环境下的原子性操作。
  • getAndIncrement()方法获取当前值并递增，避免并发冲突。
  • 通过取模运算实现循环分配。

3.2 加权轮询

加权轮询（Weighted Round Robin）是轮询算法的一种扩展，允许为每个服务器分配不同的权重。权重越高，服务器收到的请求越多。这种方法适用于服务器性能不一致的情况，确保性能较强的服务器承担更多的负载。

以下是一个Java实现的加权轮询算法示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import java.util.List;

public class WeightedRoundRobinLoadBalancer<T> {
    private final List<ServerWeight<T>> servers;
    private int totalWeight;
    private int currentIndex;
    private int currentWeight;

    public WeightedRoundRobinLoadBalancer(List<ServerWeight<T>> servers) {
        this.servers = servers;
        this.totalWeight = servers.stream().mapToInt(ServerWeight::getWeight).sum();
        this.currentIndex = -1;
        this.currentWeight = 0;
    }

    public synchronized T select() {
        while (true) {
            currentIndex = (currentIndex + 1) % servers.size();
            if (currentIndex == 0) {
                currentWeight = currentWeight - gcd();
                if (currentWeight <= 0) {
                    currentWeight = maxWeight();
                    if (currentWeight == 0)
                        return null;
                }
            }
            if (servers.get(currentIndex).getWeight() >= currentWeight) {
                return servers.get(currentIndex).getServer();
            }
        }
    }

    private int maxWeight() {
        return servers.stream().mapToInt(ServerWeight::getWeight).max().orElse(0);
    }

    private int gcd() {
        int gcd = servers.get(0).getWeight();
        for (ServerWeight<T> server : servers) {
            gcd = gcd(gcd, server.getWeight());
        }
        return gcd;
    }

    private int gcd(int a, int b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
}

class ServerWeight<T> {
    private T server;
    private int weight;

    public ServerWeight(T server, int weight) {
        this.server = server;
        this.weight = weight;
    }

    public T getServer() {
        return server;
    }

    public int getWeight() {
        return weight;
    }
}

解析：

  • 通过ServerWeight类将服务器与其权重关联。
  • 算法核心参考了“加权轮询”中的平滑加权轮询（Smooth Weighted Round Robin）思想。
  • 使用同步方法select()确保线程安全。

3.3 最少连接数

最少连接数（Least Connections）算法将请求分配给当前连接数最少的服务器。这种方法适用于请求处理时间不均匀的场景，能够动态地根据服务器的实时负载进行分配，提高系统整体性能。

以下是一个Java实现的最少连接数负载均衡算法示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class LeastConnectionsLoadBalancer<T> {
    private final List<ServerConnection<T>> servers;

    public LeastConnectionsLoadBalancer(List<ServerConnection<T>> servers) {
        this.servers = servers;
    }

    public synchronized T select() {
        ServerConnection<T> leastConnServer = null;
        int leastConnections = Integer.MAX_VALUE;
        for (ServerConnection<T> server : servers) {
            if (server.getActiveConnections() < leastConnections) {
                leastConnections = server.getActiveConnections();
                leastConnServer = server;
            }
        }
        if (leastConnServer != null) {
            leastConnServer.incrementConnections();
            return leastConnServer.getServer();
        }
        return null;
    }

    public void release(T server) {
        for (ServerConnection<T> sc : servers) {
            if (sc.getServer().equals(server)) {
                sc.decrementConnections();
                break;
            }
        }
    }
}

class ServerConnection<T> {
    private T server;
    private AtomicInteger activeConnections;

    public ServerConnection(T server) {
        this.server = server;
        this.activeConnections = new AtomicInteger(0);
    }

    public T getServer() {
        return server;
    }

    public int getActiveConnections() {
        return activeConnections.get();
    }

    public void incrementConnections() {
        activeConnections.incrementAndGet();
    }

    public void decrementConnections() {
        activeConnections.decrementAndGet();
    }
}

解析：

  • ServerConnection类跟踪每个服务器的活动连接数。
  • select()方法在同步块中遍历服务器列表，选择活动连接数最少的服务器。
  • release()方法用于在请求完成后释放连接，减少活动连接数。

3.4 哈希

哈希算法（Hash-based）通过对请求进行哈希运算，将同一客户端的请求总是分配到同一台服务器上。这种方法适用于需要会话粘性的场景，确保用户的连续请求能够在同一服务器上处理，从而避免会话信息的丢失或重新加载。

以下是一个基于一致性哈希（Consistent Hashing）的Java实现示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

public class ConsistentHashLoadBalancer<T> {
    private final SortedMap<Integer, T> circle = new TreeMap<>();
    private final int numberOfReplicas;
    private final MessageDigest md5;

    public ConsistentHashLoadBalancer(int numberOfReplicas, List<T> nodes) {
        this.numberOfReplicas = numberOfReplicas;
        try {
            this.md5 = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("MD5 not supported", e);
        }
        for (T node : nodes) {
            add(node);
        }
    }

    public void add(T node) {
        for (int i = 0; i < numberOfReplicas; i++) {
            circle.put(hash(node.toString() + i), node);
        }
    }

    public void remove(T node) {
        for (int i = 0; i < numberOfReplicas; i++) {
            circle.remove(hash(node.toString() + i));
        }
    }

    public T select(String key) {
        if (circle.isEmpty()) {
            return null;
        }
        int hash = hash(key);
        if (!circle.containsKey(hash)) {
            SortedMap<Integer, T> tailMap = circle.tailMap(hash);
            hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        }
        return circle.get(hash);
    }

    private int hash(String key) {
        md5.update(key.getBytes(StandardCharsets.UTF_8));
        byte[] digest = md5.digest();
        return ((digest[3] & 0xFF) << 24) | ((digest[2] & 0xFF) << 16) |
               ((digest[1] & 0xFF) << 8) | (digest[0] & 0xFF);
    }
}

解析：

  • 使用一致性哈希算法，将服务器节点映射到哈希环上。
  • numberOfReplicas参数用于增加虚拟节点，提升负载均衡的均匀性。
  • 通过哈希运算确保相同的Key总是映射到相同的服务器。
  • 当服务器加入或移除时，只有部分Key需要重新映射，降低系统调整成本。

3.5 随机

随机（Random）算法通过随机选择一台服务器来分配请求。这种方法实现简单，能够在大规模服务器集群中提供较为均匀的分配效果，但在短期内可能会出现某些服务器负载较高的情况。

以下是一个Java实现的随机负载均衡算法示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.List;
import java.util.Random;

public class RandomLoadBalancer<T> {
    private final List<T> servers;
    private final Random random;

    public RandomLoadBalancer(List<T> servers) {
        this.servers = servers;
        this.random = new Random();
    }

    public T select() {
        if (servers.isEmpty()) {
            return null;
        }
        int index = random.nextInt(servers.size());
        return servers.get(index);
    }
}

解析：

  • 使用Random类生成一个随机索引，选择对应的服务器。
  • 简单高效，但缺乏对服务器负载的感知。

4. 示例演示

为了更好地理解上述负载均衡算法的应用，下面我们将通过一个简单的Java项目示例，展示如何实现并使用这些负载均衡算法。

假设我们有一组服务器，表示为字符串：

1
List<String> servers = Arrays.asList("Server1", "Server2", "Server3");

4.1 轮询示例

1
2
3
4
RoundRobinLoadBalancer<String> rrLoadBalancer = new RoundRobinLoadBalancer<>(servers);
for (int i = 0; i < 6; i++) {
    System.out.println(rrLoadBalancer.select());
}

输出：

1
2
3
4
5
6
Server1
Server2
Server3
Server1
Server2
Server3

4.2 加权轮询示例

1
2
3
4
5
6
7
8
9
List<ServerWeight<String>> weightedServers = Arrays.asList(
    new ServerWeight<>("Server1", 1),
    new ServerWeight<>("Server2", 2),
    new ServerWeight<>("Server3", 3)
);
WeightedRoundRobinLoadBalancer<String> wrrLoadBalancer = new WeightedRoundRobinLoadBalancer<>(weightedServers);
for (int i = 0; i < 6; i++) {
    System.out.println(wrrLoadBalancer.select());
}

输出（可能为）：

1
2
3
4
5
6
Server3
Server2
Server3
Server1
Server3
Server2

4.3 最少连接数示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
List<ServerConnection<String>> leastConnServers = Arrays.asList(
    new ServerConnection<>("Server1"),
    new ServerConnection<>("Server2"),
    new ServerConnection<>("Server3")
);
LeastConnectionsLoadBalancer<String> lcLoadBalancer = new LeastConnectionsLoadBalancer<>(leastConnServers);

// 模拟请求分配
for (int i = 0; i < 5; i++) {
    String server = lcLoadBalancer.select();
    System.out.println("Assigned to: " + server);
    // 假设请求完成，释放连接
    lcLoadBalancer.release(server);
}

输出：

1
2
3
4
5
Assigned to: Server1
Assigned to: Server2
Assigned to: Server3
Assigned to: Server1
Assigned to: Server2

4.4 一致性哈希示例

1
2
3
4
5
ConsistentHashLoadBalancer<String> chLoadBalancer = new ConsistentHashLoadBalancer<>(100, servers);
String[] keys = {"User1", "User2", "User3", "User4", "User5"};
for (String key : keys) {
    System.out.println(key + " is mapped to " + chLoadBalancer.select(key));
}

输出（根据哈希结果可能不同）：

1
2
3
4
5
User1 is mapped to Server2
User2 is mapped to Server3
User3 is mapped to Server1
User4 is mapped to Server2
User5 is mapped to Server3

4.5 随机示例

1
2
3
4
RandomLoadBalancer<String> randomLoadBalancer = new RandomLoadBalancer<>(servers);
for (int i = 0; i < 5; i++) {
    System.out.println(randomLoadBalancer.select());
}

输出：

1
2
3
4
5
Server2
Server1
Server3
Server2
Server3

5. 总结

本文，我们分析了负载均衡常见的 5种算法，并且通过代码示例进行了详细地分析。作为 Java程序员，强烈掌握这 5种算法，在实际工作中，我们可以通过合理地选择和实现负载均衡算法，能够显著提升系统的稳定性和性能。

6. 学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

drawing