多种负载均衡算法及其Java代码实现("Java实现多种负载均衡算法详解与实践")

原创

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

Java实现多种负载均衡算法详解与实践

一、负载均衡算法概述

负载均衡算法是分布式系统中常用的一种技术，核心用于分散请求到多个服务器上，以保持系统的稳定性和高效性。常见的负载均衡算法包括轮询、最小连接数、加权轮询、加权最小连接数等。

二、轮询算法

轮询算法是最易懂的负载均衡算法，按照请求的顺序依次分配到服务器上。下面是轮询算法的Java代码实现：


import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class RoundRobin {
    private final List servers;
    private final AtomicInteger index = new AtomicInteger(0);
    public RoundRobin(List servers) {
        this.servers = servers;
    }
    public String selectServer() {
        return servers.get(index.getAndAdd(1) % servers.size());
    }
}

三、最小连接数算法

最小连接数算法将请求分配到当前连接数最少的服务器上。下面是最小连接数算法的Java代码实现：


import java.util.Comparator;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
public class LeastConnections {
    private final List servers;
    private final ConcurrentHashMap serverConnections = new ConcurrentHashMap<>();
    public LeastConnections(List servers) {
        this.servers = servers;
    }
    public String selectServer() {
        return servers.stream()
                .min(Comparator.comparingInt(serverConnections::get))
                .orElse(null);
    }
    public void addConnection(String server) {
        serverConnections.merge(server, 1, Integer::sum);
    }
    public void removeConnection(String server) {
        serverConnections.merge(server, 1, (a, b) -> a - b);
    }
}

四、加权轮询算法

加权轮询算法是在轮询算法在出现的同时，为每个服务器设置一个权重，按照权重分配请求。下面是加权轮询算法的Java代码实现：


import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class WeightedRoundRobin {
    private final List serverWeights;
    private final AtomicInteger currentIndex = new AtomicInteger(0);
    private int currentWeight;
    private int maxWeight;
    public WeightedRoundRobin(List serverWeights) {
        this.serverWeights = serverWeights;
        for (ServerWeight serverWeight : serverWeights) {
            maxWeight += serverWeight.getWeight();
        }
    }
    public String selectServer() {
        while (true) {
            ServerWeight serverWeight = serverWeights.get(currentIndex.get() % serverWeights.size());
            if (currentWeight >= maxWeight) {
                currentWeight = 0;
                currentIndex.set(0);
            }
            if (currentWeight < serverWeight.getWeight()) {
                currentWeight++;
                return serverWeight.getServer();
            }
            currentWeight++;
            currentIndex.incrementAndGet();
        }
    }
    private static class ServerWeight {
        private final String server;
        private final int weight;
        public ServerWeight(String server, int weight) {
            this.server = server;
            this.weight = weight;
        }
        public String getServer() {
            return server;
        }
        public int getWeight() {
            return weight;
        }
    }
}

五、加权最小连接数算法

加权最小连接数算法是结合了最小连接数和加权轮询的算法，按照服务器的权重和连接数来分配请求。下面是加权最小连接数算法的Java代码实现：


import java.util.Comparator;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
public class WeightedLeastConnections {
    private final List serverWeights;
    private final ConcurrentHashMap serverConnections = new ConcurrentHashMap<>();
    public WeightedLeastConnections(List serverWeights) {
        this.serverWeights = serverWeights;
    }
    public String selectServer() {
        return serverWeights.stream()
                .min(Comparator.comparingInt(server -> serverConnections.getOrDefault(server.getServer(), 0) * server.getWeight()))
                .map(ServerWeight::getServer)
                .orElse(null);
    }
    public void addConnection(String server) {
        serverConnections.merge(server, 1, Integer::sum);
    }
    public void removeConnection(String server) {
        serverConnections.merge(server, 1, (a, b) -> a - b);
    }
    private static class ServerWeight {
        private final String server;
        private final int weight;
        public ServerWeight(String server, int weight) {
            this.server = server;
            this.weight = weight;
        }
        public String getServer() {
            return server;
        }
        public int getWeight() {
            return weight;
        }
    }
}