多种负载均衡算法及其Java代码实现(负载均衡算法详解及Java实现指南)

原创

ithorizon 6个月前 (10-21) 阅读数 19 #后端开发

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

一、负载均衡算法简介

负载均衡算法是一种用于分配工作负载到多个服务器或资源的方法，以尽或许缩减损耗系统性能和资源利用率。本文将介绍几种常见的负载均衡算法，并给出相应的Java代码实现。

二、轮询算法（Round Robin）

轮询算法是最简洁的负载均衡算法，它将请求按顺序均匀地分配到服务器列表中。当服务器列表中某个服务器处理完一个请求后，它将被移动到列表的末尾，等待下一次请求。


public class RoundRobin {
    private List servers;
    private int index;
    public RoundRobin(List servers) {
        this.servers = servers;
        this.index = 0;
    }
    public String getNextServer() {
        String server = servers.get(index);
        index = (index + 1) % servers.size();
        return server;
    }
}

三、加权轮询算法（Weighted Round Robin）

加权轮询算法是轮询算法的改进版，它按照服务器性能和负载情况为每个服务器分配一个权重。权重高的服务器会被优先分配请求。


public class WeightedRoundRobin {
    private List servers;
    private List weights;
    private int index;
    private int currentWeight;
    private int maxWeight;
    public WeightedRoundRobin(List servers, List weights) {
        this.servers = servers;
        this.weights = weights;
        this.index = 0;
        this.currentWeight = 0;
        this.maxWeight = weights.stream().max(Integer::compare).get();
    }
    public String getNextServer() {
        while (currentWeight < maxWeight) {
            currentWeight += weights.get(index);
            if (currentWeight >= maxWeight) {
                return servers.get(index);
            }
        }
        currentWeight = 0;
        index = (index + 1) % servers.size();
        return getNextServer();
    }
}

四、最小连接数算法（Least Connections）

最小连接数算法将请求分配给当前连接数最少的服务器。这种方法可以避免某些服务器过载，而其他服务器空闲的情况。


public class LeastConnections {
    private List servers;
    private Map connections;
    public LeastConnections(List servers) {
        this.servers = servers;
        this.connections = new HashMap<>();
        for (String server : servers) {
            connections.put(server, 0);
        }
    }
    public String getNextServer() {
        String minServer = null;
        int minConnections = Integer.MAX_VALUE;
        for (Map.Entry entry : connections.entrySet()) {
            if (entry.getValue() < minConnections) {
                minServer = entry.getKey();
                minConnections = entry.getValue();
            }
        }
        connections.put(minServer, minConnections + 1);
        return minServer;
    }
    public void releaseServer(String server) {
        int currentConnections = connections.get(server);
        connections.put(server, currentConnections - 1);
    }
}

五、加权最小连接数算法（Weighted Least Connections）

加权最小连接数算法是最小连接数算法的改进版，它考虑了服务器的性能和负载情况，为每个服务器分配一个权重。


public class WeightedLeastConnections {
    private List servers;
    private Map connections;
    private Map weights;
    public WeightedLeastConnections(List servers, List weights) {
        this.servers = servers;
        this.connections = new HashMap<>();
        this.weights = new HashMap<>();
        for (int i = 0; i < servers.size(); i++) {
            connections.put(servers.get(i), 0);
            weights.put(servers.get(i), weights.get(i));
        }
    }
    public String getNextServer() {
        String minServer = null;
        double minRatio = Double.MAX_VALUE;
        for (Map.Entry entry : connections.entrySet()) {
            double ratio = (double) entry.getValue() / weights.get(entry.getKey());
            if (ratio < minRatio) {
                minServer = entry.getKey();
                minRatio = ratio;
            }
        }
        connections.put(minServer, connections.get(minServer) + 1);
        return minServer;
    }
    public void releaseServer(String server) {
        int currentConnections = connections.get(server);
        connections.put(server, currentConnections - 1);
    }
}

六、源IP哈希算法（Source IP Hash）

源IP哈希算法按照请求的源IP地址进行哈希计算，然后将请求分配到哈希值对应的服务器。这种方法可以保证来自同一客户端的请求总是被分配到同一个服务器，从而保持会话状态。


public class SourceIPHash {
    private List servers;
    private Map serverMap;
    public SourceIPHash(List servers) {
        this.servers = servers;
        this.serverMap = new HashMap<>();
        int index = 0;
        for (String server : servers) {
            for (int i = 0; i < 4; i++) {
                serverMap.put(index, server);
                index = (index + 1) % servers.size();
            }
        }
    }
    public String getNextServer(String ip) {
        int hash = ip.hashCode();
        return serverMap.get(Math.abs(hash) % serverMap.size());
    }
}