多种负载均衡算法的 Java 代码实现

在现代的分布式系统中，负载均衡是确保系统高效运行和资源合理分配的关键技术。本文将介绍几种常见的负载均衡算法，并提供相应的 Java 代码实现。

轮询算法（Round Robin）

轮询算法是一种简单且常见的负载均衡策略。它按照顺序依次将请求分配到各个服务器节点。

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

class Server {
    private String name;

    public Server(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

class RoundRobinLoadBalancer {
    private List<Server> servers;
    private int currentIndex;

    public RoundRobinLoadBalancer(List<Server> servers) {
        this.servers = servers;
        this.currentIndex = 0;
    }

    public Server getNextServer() {
        Server server = servers.get(currentIndex);
        currentIndex = (currentIndex + 1) % servers.size();
        return server;
    }

    public static void main(String[] args) {
        List<Server> servers = new ArrayList<>();
        servers.add(new Server("Server 1"));
        servers.add(new Server("Server 2"));
        servers.add(new Server("Server 3"));

        RoundRobinLoadBalancer loadBalancer = new RoundRobinLoadBalancer(servers);

        for (int i = 0; i < 10; i++) {
            Server selectedServer = loadBalancer.getNextServer();
            System.out.println("Selected Server: " + selectedServer.getName());
        }
    }
}

随机算法（Random）

随机算法通过随机选择服务器节点来分配请求，具有一定的随机性。

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

class RandomLoadBalancer {
    private List<Server> servers;

    public RandomLoadBalancer(List<Server> servers) {
        this.servers = servers;
    }

    public Server getRandomServer() {
        Random random = new Random();
        int index = random.nextInt(servers.size());
        return servers.get(index);
    }

    public static void main(String[] args) {
        List<Server> servers = new ArrayList<>();
        servers.add(new Server("Server 1"));
        servers.add(new Server("Server 2"));
        servers.add(new Server("Server 3"));

        RandomLoadBalancer loadBalancer = new RandomLoadBalancer(servers);

        for (int i = 0; i < 10; i++) {
            Server selectedServer = loadBalancer.getRandomServer();
            System.out.println("Selected Server: " + selectedServer.getName());
        }
    }
}

加权轮询算法（Weighted Round Robin）

加权轮询算法考虑了服务器节点的权重，根据权重比例分配请求。

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

class WeightedServer {
    private String name;
    private int weight;

    public WeightedServer(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public int getWeight() {
        return weight;
    }
}

class WeightedRoundRobinLoadBalancer {
    private List<WeightedServer> servers;
    private int[] weights;
    private int totalWeight;
    private int currentIndex;

    public WeightedRoundRobinLoadBalancer(List<WeightedServer> servers) {
        this.servers = servers;
        this.weights = new int[servers.size()];
        int i = 0;
        for (WeightedServer server : servers) {
            weights[i++] = server.getWeight();
        }
        totalWeight = 0;
        for (int weight : weights) {
            totalWeight += weight;
        }
        currentIndex = 0;
    }

    public WeightedServer getNextServer() {
        int currentWeight = 0;
        int selectedIndex = currentIndex;
        while (currentWeight < weights[selectedIndex]) {
            currentWeight += weights[selectedIndex];
            selectedIndex = (selectedIndex + 1) % servers.size();
        }
        currentIndex = selectedIndex;
        return servers.get(currentIndex);
    }

    public static void main(String[] args) {
        List<WeightedServer> servers = new ArrayList<>();
        servers.add(new WeightedServer("Server 1", 2));
        servers.add(new WeightedServer("Server 2", 3));
        servers.add(new WeightedServer("Server 3", 5));

        WeightedRoundRobinLoadBalancer loadBalancer = new WeightedRoundRobinLoadBalancer(servers);

        for (int i = 0; i < 10; i++) {
            WeightedServer selectedServer = loadBalancer.getNextServer();
            System.out.println("Selected Server: " + selectedServer.getName());
        }
    }
}

通过以上几种负载均衡算法的 Java 代码实现，我们可以根据实际需求选择合适的算法来优化系统的性能和资源利用效率。