负载均衡算法：轮询、加权轮询、随机、加权随机

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

public class LoadBalancer {
    private List<String> servers;
    private int currentIndex;
    private int[] weights;
    private int totalWeight;
    private Random random;

    public LoadBalancer() {
        this.servers = new ArrayList<>();
        this.currentIndex = 0;
        this.random = new Random();
    }

    // 添加服务器
    public void addServer(String server) {
        servers.add(server);
    }

    // 轮询算法选择服务器
    public synchronized String roundRobin() {
        if (servers.isEmpty()) {
            return null;
        }
        String server = servers.get(currentIndex);
        currentIndex = (currentIndex + 1) % servers.size();
        return server;
    }

    // 加权轮询算法选择服务器
    public synchronized String weightedRoundRobin() {
        if (servers.isEmpty()) {
            return null;
        }
        if (weights == null || weights.length != servers.size()) {
            weights = new int[servers.size()];
            for (int i = 0; i < servers.size(); i++) {
                weights[i] = i + 1; // 默认权重为服务器索引 + 1
                totalWeight += weights[i];
            }
        }
        int index = currentIndex;
        currentIndex = (currentIndex + 1) % servers.size();
        return servers.get(index);
    }

    // 随机算法选择服务器
    public synchronized String random() {
        if (servers.isEmpty()) {
            return null;
        }
        int index = random.nextInt(servers.size());
        return servers.get(index);
    }

    // 加权随机算法选择服务器
    public synchronized String weightedRandom() {
        if (servers.isEmpty()) {
            return null;
        }
        if (weights == null || weights.length != servers.size()) {
            weights = new int[servers.size()];
            for (int i = 0; i < servers.size(); i++) {
                weights[i] = i + 1; // 默认权重为服务器索引 + 1
                totalWeight += weights[i];
            }
        }
        int index = random.nextInt(totalWeight);
        int sum = 0;
        for (int i = 0; i < servers.size(); i++) {
            sum += weights[i];
            if (index < sum) {
                return servers.get(i);
            }
        }
        return servers.get(servers.size() - 1);
    }

    public static void main(String[] args) {
        LoadBalancer loadBalancer = new LoadBalancer();
        loadBalancer.addServer("Server1");
        loadBalancer.addServer("Server2");
        loadBalancer.addServer("Server3");

        // 模拟请求
        for (int i = 0; i < 10; i++) {
            String server = loadBalancer.roundRobin();
            System.out.println("Round Robin: Request " + (i + 1) + " sent to " + server);
        }

        for (int i = 0; i < 10; i++) {
            String server = loadBalancer.weightedRoundRobin();
            System.out.println("Weighted Round Robin: Request " + (i + 1) + " sent to " + server);
        }

        for (int i = 0; i < 10; i++) {
            String server = loadBalancer.random();
            System.out.println("Random: Request " + (i + 1) + " sent to " + server);
        }

        for (int i = 0; i < 10; i++) {
            String server = loadBalancer.weightedRandom();
            System.out.println("Weighted Random: Request " + (i + 1) + " sent to " + server);
        }
    }
}

在上述代码中，实现了轮询、加权轮询、随机、加权随机四种负载均衡算法