三种简单的负载均衡算法及Java代码实现

素颜马尾好姑娘i 2023-09-27 18:54 120阅读 0赞

本文介绍了三种简单的负载均衡算法，分别是轮询算法、随机算法和加权轮询算法，同时给出了Java代码实现。这些算法可根据不同的系统场景和需要选择使用，帮助均衡分配请求，提高系统性能和稳定性。

#### 1. 轮询算法（Round Robin） ####

轮询算法即每个请求按照顺序依次分配到不同的服务器上，循环往复。对于有大量请求的系统，此算法效果较好。  
Java代码实现：

public class RoundRobinLoadBalancer implements LoadBalancer {
        
         private List<String> servers = new ArrayList<>();
        private int currentServerIndex = 0;
         @Override
        public void addServer(String server) {
        
            servers.add(server);
        }
         @Override
        public String getNextServer() {
        
            if (servers.isEmpty()) {
        
                return null;
            }
            String server = servers.get(currentServerIndex);
            currentServerIndex = (currentServerIndex + 1) % servers.size();
            return server;
        }
    }

#### 2. 随机算法（Random） ####

随机算法即每个请求随机分配到某一个服务器上，适用于服务器间压力分布相对均匀的场景。  
Java代码实现：

public class RandomLoadBalancer implements LoadBalancer {
        
         private List<String> servers = new ArrayList<>();
         @Override
        public void addServer(String server) {
        
            servers.add(server);
        }
         @Override
        public String getNextServer() {
        
            if (servers.isEmpty()) {
        
                return null;
            }
            int randomIndex = new Random().nextInt(servers.size());
            return servers.get(randomIndex);
        }
    }

#### 3. 加权轮询算法（Weight Round Robin） ####

加权轮询算法即每个请求按照权重依次分配到不同的服务器上，权重越高的服务器被分配到的请求越多。  
Java代码实现：

public class WeightRoundRobinLoadBalancer implements LoadBalancer {
        
         private Map<String, Integer> serverWeights = new HashMap<>();
        private List<String> servers = new ArrayList<>();
        private int currentServerIndex = 0;
        private int gcdServerWeight = 1;
        private int maxServerWeight = 0;
         @Override
        public void addServer(String server, int weight) {
        
            serverWeights.put(server, weight);
            maxServerWeight = Math.max(maxServerWeight, weight);
            int gcd = gcdServerWeight(gcdServerWeight, weight);
            gcdServerWeight = Math.max(gcdServerWeight, gcd);
            for (Map.Entry<String, Integer> entry : serverWeights.entrySet()) {
        
                servers.add(entry.getKey());
            }
        }
         @Override
        public String getNextServer() {
        
            if (servers.isEmpty()) {
        
                return null;
            }
            String server = getNextWeightedServer();
            currentServerIndex = (currentServerIndex + 1) % servers.size();
            return server;
        }
         private String getNextWeightedServer() {
        
            String selectedServer = null;
            int total = 0;
            while (selectedServer == null) {
        
                total += gcdServerWeight;
                if (total >= maxServerWeight) {
        
                    total = maxServerWeight;
                }
                int index = (currentServerIndex + 1) % servers.size();
                String server = servers.get(index);
                if (serverWeights.get(server) >= total) {
        
                    selectedServer = server;
                }
                currentServerIndex = index;
            }
            return selectedServer;
        }
         private int gcdServerWeight(int a, int b) {
        
            return b == 0 ? a : gcdServerWeight(b, a % b);
        }
    }

以上是三种简单的负载均衡算法及其Java代码实现，根据不同的场景和需要，可以选择相应的算法进行负载均衡。