微服务架构中常见的负载均衡算法

来自宇宙的曹先生

已于 2023-10-19 19:49:49 修改

阅读量227

点赞数

文章标签：架构微服务负载均衡

于 2023-10-13 16:51:51 首次发布

本文链接：https://blog.csdn.net/m0_54187478/article/details/133813012

版权

1.轮询（Round Robin）：

轮询算法按顺序将每个请求依次分配给服务器。每个服务器按照它们在轮询列表中的位置依次接收请求。轮询算法简单且均匀，适用于负载相对均衡的情况。

import java.util.List;

public class RoundRobinLoadBalancer {
    private List<String> servers; // 存储服务器列表
    private int currentIndex;     // 当前选择的服务器索引

    public RoundRobinLoadBalancer(List<String> serverList) {
        this.servers = serverList;
        this.currentIndex = 0; // 初始化索引为0
    }

    // 获取下一个服务器
    public synchronized String getNextServer() {
        if (servers.isEmpty()) {
            return null; // 服务器列表为空时返回null
        }

        String selectedServer = servers.get(currentIndex); // 获取当前索引对应的服务器
        currentIndex = (currentIndex + 1) % servers.size(); // 更新索引，循环遍历服务器列表

        return selectedServer; // 返回选择的服务器
    }

    public static void main(String[] args) {
        List<String> serverList = List.of("Server1", "Server2", "Server3");
        RoundRobinLoadBalancer loadBalancer = new RoundRobinLoadBalancer(serverList);

        for (int i = 0; i < 10; i++) {
            String selectedServer = loadBalancer.getNextServer();
            System.out.println("Request " + (i + 1) + " is sent to " + selectedServer);
        }
    }
}

2.随机（Random）：

随机算法从可用服务器中随机选择一个来处理每个请求。这种方法不考虑服务器的实际负载，适用于负载变化不大的场景。

import java.util.List;
import java.util.Random;

public class RandomLoadBalancer {
    private List<String> servers; // 存储服务器列表
    private Random random; // 用于生成随机数

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

    // 获取随机选择的服务器
    public String getRandomServer() {
        if (servers.isEmpty()) {
            return null; // 服务器列表为空时返回null
        }

        int randomIndex = random.nextInt(servers.size()); // 生成随机索引
        return servers.get(randomIndex); // 返回随机选择的服务器
    }

    public static void main(String[] args) {
        List<String> serverList = List.of("Server1", "Server2", "Server3");
        RandomLoadBalancer loadBalancer = new RandomLoadBalancer(serverList);

        for (int i = 0; i < 10; i++) {
            String selectedServer = loadBalancer.getRandomServer();
            System.out.println("Request " + (i + 1) + " is sent to " + selectedServer);
        }
    }
}

3.最少连接（Least Connections）：

最少连接算法将请求发送到当前连接数最少的服务器，以确保负载最小化。这对于服务器负载不均衡的情况非常有用，但需要实时监控连接数。

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class LeastConnectionsLoadBalancer {
    private List<String> servers; // 存储服务器列表
    private Map<String, Integer> connections; // 存储每台服务器的连接数

    public LeastConnectionsLoadBalancer(List<String> serverList) {
        this.servers = serverList;
        this.connections = new HashMap<>();

        // 初始化每台服务器的连接数为0
        for (String server : servers) {
            connections.put(server, 0);
        }
    }

    // 获取连接数最少的服务器
    public String getLeastConnectionsServer() {
        if (servers.isEmpty()) {
            return null; // 服务器列表为空时返回null
        }

        String selectedServer = null;
        int minConnections = Integer.MAX_VALUE;

        // 寻找连接数最少的服务器
        for (String server : servers) {
            int serverConnections = connections.get(server);
            if (serverConnections < minConnections) {
                selectedServer = server;
                minConnections = serverConnections;
            }
        }

        // 增加选中服务器的连接数
        if (selectedServer != null) {
            connections.put(selectedServer, minConnections + 1);
        }

        return selectedServer;
    }

    public static void main(String[] args) {
        List<String> serverList = List.of("Server1", "Server2", "Server3");
        LeastConnectionsLoadBalancer loadBalancer = new LeastConnectionsLoadBalancer(serverList);

        for (int i = 0; i < 10; i++) {
            String selectedServer = loadBalancer.getLeastConnectionsServer();
            System.out.println("Request " + (i + 1) + " is sent to " + selectedServer);
        }
    }
}

4. IP哈希（IP Hash）：

IP哈希算法根据客户端IP地址的哈希值来选择服务器。这确保相同的客户端IP始终被路由到相同的服务器，适用于会话保持或需要一致性的场景。

public class IPHashAlgorithm {
    public static String[] servers = { "Server1", "Server2", "Server3" };

    public static String getServerByIP(String ipAddress) {
        // 将IPv4地址分割成四部分
        String[] parts = ipAddress.split("\\.");

        // 初始化哈希值
        int hash = 0;

        // 计算哈希值
        for (String part : parts) {
            int octet = Integer.parseInt(part);
            hash = (hash << 8) | octet; // 左移8位并加上当前部分的值
        }

        // 取模来选择服务器
        int serverIndex = hash % servers.length;
        return servers[serverIndex];
    }

    public static void main(String[] args) {
        String ipAddress1 = "192.168.1.1";
        String ipAddress2 = "10.0.0.1";

        String server1 = getServerByIP(ipAddress1);
        String server2 = getServerByIP(ipAddress2);

        System.out.println("IP地址 " + ipAddress1 + " 映射到服务器 " + server1);
        System.out.println("IP地址 " + ipAddress2 + " 映射到服务器 " + server2);
    }
}