常见负载均衡算法demo

1. 随机算法（Random）：随机选择一个服务器来处理请求。

2. 轮询算法（Round Robin）：按照顺序依次将请求分发给每个服务器，循环往复。

3. 加权轮询算法（Weighted Round Robin）：根据服务器的权重，按照一定的比例分发请求。

4. 最少连接算法（Least Connection）：选择当前连接数最少的服务器来处理请求。

5. IP哈希算法（IP Hash）：根据客户端的IP地址进行哈希计算，将请求分发给对应的服务器。

以下是常见负载均衡算法的最佳使用场景：

1. 随机算法（Random）：适用于无需考虑服务器负载情况的场景。每次请求都随机选择一个服务器处理，简单且均衡地分发请求。

2. 轮询算法（Round Robin）：适用于服务器性能相近的场景。按照顺序将请求依次分发给每个服务器，实现请求的均匀分配。

3. 加权轮询算法（Weighted Round Robin）：适用于服务器性能不均衡的场景。通过为每个服务器分配不同的权重，可以根据服务器的性能来调整请求的分发比例。

4. 最少连接算法（Least Connection）：适用于处理长连接或连接持续时间较长的场景。选择当前连接数最少的服务器来处理请求，可以有效地分担服务器的负载。

5. IP哈希算法（IP Hash）：适用于需要保持会话一致性的场景。根据客户端的IP地址进行哈希计算，将同一客户端的请求始终分发到同一台服务器，确保会话的连续性。

package com.xiang.design.create.loadBalancer;

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

public class LoadBalancer {
    private  static List<String> servers;
    private Random random;

    public LoadBalancer() {
        servers = new ArrayList<>();
        servers.add("192.168.0.1");
        servers.add("192.168.0.2");
        servers.add("192.168.0.3");
        random = new Random();
    }

    public String randomAlgorithm() {
        int index = random.nextInt(servers.size());
        return servers.get(index);
    }

    public String roundRobinAlgorithm() {
        // 使用静态变量记录当前请求的索引
        int index = RequestCounter.getNextIndex(servers.size());
        return servers.get(index);
    }

    public String weightedRoundRobinAlgorithm() {
        // 假设服务器的权重分别为2、3、5
        int[] weights = {2, 3, 5};
        int totalWeight = 0;
        for (int weight : weights) {
            totalWeight += weight;
        }

        int randomWeight = random.nextInt(totalWeight);
        int sum = 0;
        int index = 0;
        for (int weight : weights) {
            sum += weight;
            if (randomWeight < sum) {
                return servers.get(index);
            }
            index++;
        }

        return servers.get(servers.size() - 1);
    }

    public String leastConnectionAlgorithm() {
        // 假设服务器的当前连接数分别为10、5、8
        int[] connections = {10, 5, 8};
        int minConnections = Integer.MAX_VALUE;
        int index = 0;
        for (int i = 0; i < connections.length; i++) {
            if (connections[i] < minConnections) {
                minConnections = connections[i];
                index = i;
            }
        }

        return servers.get(index);
    }

    public String ipHashAlgorithm(String clientIp) {
        int hashCode = clientIp.hashCode();
        int index = Math.abs(hashCode) % servers.size();
        return servers.get(index);
    }

    public static void main(String[] args) {
        LoadBalancer loadBalancer = new LoadBalancer();

        // 使用随机算法
        String randomServer = loadBalancer.randomAlgorithm();
        System.out.println("Random algorithm: " + randomServer);

        // 使用轮询算法
        String roundRobinServer1 = loadBalancer.roundRobinAlgorithm();
        String roundRobinServer2 = loadBalancer.roundRobinAlgorithm();
        System.out.println("Round Robin algorithm: " + roundRobinServer1 + ", " + roundRobinServer2);

        // 使用加权轮询算法
        String weightedRoundRobinServer1 = loadBalancer.weightedRoundRobinAlgorithm();
        String weightedRoundRobinServer2 = loadBalancer.weightedRoundRobinAlgorithm();
        System.out.println("Weighted Round Robin algorithm: " + weightedRoundRobinServer1 + ", " + weightedRoundRobinServer2);

        // 使用最少连接算法
        String leastConnectionServer = loadBalancer.leastConnectionAlgorithm();
        System.out.println("Least Connection algorithm: " + leastConnectionServer);

        // 使用IP哈希算法
        String clientIp = "192.168.1.100";
        String ipHashServer = loadBalancer.ipHashAlgorithm(clientIp);
        System.out.println("IP Hash algorithm: " + ipHashServer);
    }
}

class RequestCounter {
    private static int index = 0;

    public static synchronized int getNextIndex(int size) {
        int currentIndex = index;
        index = (index + 1) % size;
        return currentIndex;
    }
}