从零手写实现 nginx-32-load balance 负载均衡算法 java 实现

nginx 支持哪几种负载均衡算法？

Nginx 支持以下几种主要的负载均衡算法：

1. 轮询（Round Robin）

   • 默认的负载均衡算法，请求依次分配给每个后端服务器。

2. 权重轮询（Weighted Round Robin）

   • 基于权重进行轮询，权重越高的服务器分配的请求越多。

3. 最少连接（Least Connections）

   • 新请求分配给当前活动连接数最少的服务器。

4. IP 哈希（IP Hash）

   • 根据客户端的 IP 地址分配请求，确保相同 IP 地址的请求分配到同一台服务器上。

5. 一致性哈希（Hash）

   • 根据用户定义的键（如 URL、cookie 等）分配请求，确保相同键的请求分配到同一台服务器上。

示例配置

1. 轮询（Round Robin）

conf

代码解读

复制代码

upstream my_backend { server 192.168.0.1; server 192.168.0.2; server 192.168.0.3; } server { listen 80; server_name www.example.com; location / { proxy_pass http://my_backend; } }

2. 权重轮询（Weighted Round Robin）

conf

代码解读

复制代码

upstream my_backend { server 192.168.0.1 weight=3; server 192.168.0.2 weight=2; server 192.168.0.3 weight=1; } server { listen 80; server_name www.example.com; location / { proxy_pass http://my_backend; } }

3. 最少连接（Least Connections）

conf

代码解读

复制代码

upstream my_backend { least_conn; server 192.168.0.1; server 192.168.0.2; server 192.168.0.3; } server { listen 80; server_name www.example.com; location / { proxy_pass http://my_backend; } }

4. IP 哈希（IP Hash）

conf

代码解读

复制代码

upstream my_backend { ip_hash; server 192.168.0.1; server 192.168.0.2; server 192.168.0.3; } server { listen 80; server_name www.example.com; location / { proxy_pass http://my_backend; } }

5. 一致性哈希（Hash）

conf

代码解读

复制代码

upstream my_backend { hash $request_uri; server 192.168.0.1; server 192.168.0.2; server 192.168.0.3; } server { listen 80; server_name www.example.com; location / { proxy_pass http://my_backend; } }

总结

Nginx 支持多种负载均衡算法，包括轮询、权重轮询、最少连接、IP 哈希和一致性哈希。

每种算法适用于不同的场景，可以根据具体需求选择合适的算法来优化负载均衡策略。

java 实现

轮询算法（Round Robin）

java

代码解读

复制代码

import java.util.List; import java.util.concurrent.atomic.AtomicInteger; public class RoundRobinLoadBalancer { private List<String> servers; private AtomicInteger currentIndex; public RoundRobinLoadBalancer(List<String> servers) { this.servers = servers; this.currentIndex = new AtomicInteger(0); } public String getNextServer() { int index = currentIndex.getAndUpdate(i -> (i + 1) % servers.size()); return servers.get(index); } public static void main(String[] args) { List<String> servers = List.of("192.168.0.1", "192.168.0.2", "192.168.0.3"); RoundRobinLoadBalancer loadBalancer = new RoundRobinLoadBalancer(servers); // 模拟10次请求 for (int i = 0; i < 10; i++) { String server = loadBalancer.getNextServer(); System.out.println("Redirecting request to: " + server); } } }

java 如何实现权重轮询算法？

实现权重轮询算法（Weighted Round Robin）可以根据每个服务器的权重来分配请求，权重越高的服务器接收的请求越多。

整理了一份面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafka 面试专题

需要全套面试笔记的【点击此处即可】即可免费获取

java

代码解读

复制代码

import java.util.ArrayList; import java.util.List; class Server { String ip; int weight; Server(String ip, int weight) { this.ip = ip; this.weight = weight; } } public class WeightedRoundRobinLoadBalancer { private List<Server> servers; private List<String> weightedServerList; private int currentIndex; public WeightedRoundRobinLoadBalancer(List<Server> servers) { this.servers = servers; this.weightedServerList = new ArrayList<>(); this.currentIndex = 0; // 根据服务器的权重初始化加权后的服务器列表 for (Server server : servers) { for (int i = 0; i < server.weight; i++) { weightedServerList.add(server.ip); } } } public String getNextServer() { if (weightedServerList.isEmpty()) { throw new IllegalStateException("No servers available"); } String server = weightedServerList.get(currentIndex); currentIndex = (currentIndex + 1) % weightedServerList.size(); return server; } public static void main(String[] args) { List<Server> servers = List.of( new Server("192.168.0.1", 3), // 权重为3 new Server("192.168.0.2", 2), // 权重为2 new Server("192.168.0.3", 1) // 权重为1 ); WeightedRoundRobinLoadBalancer loadBalancer = new WeightedRoundRobinLoadBalancer(servers); // 模拟10次请求 for (int i = 0; i < 10; i++) { String server = loadBalancer.getNextServer(); System.out.println("Redirecting request to: " + server); } } }

java 如何实现最少连接算法？具体实现

最少连接算法（Least Connections）是一种负载均衡算法，它将请求分配给当前活动连接数最少的服务器。

在 Java 中实现这个算法，需要跟踪每个服务器的当前连接数，并在每次请求时选择连接数最少的服务器。

java

代码解读

复制代码

import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.concurrent.atomic.AtomicInteger; class Server { String ip; AtomicInteger activeConnections; Server(String ip) { this.ip = ip; this.activeConnections = new AtomicInteger(0); } } public class LeastConnectionsLoadBalancer { private List<Server> servers; public LeastConnectionsLoadBalancer(List<Server> servers) { this.servers = servers; } public Server getNextServer() { if (servers.isEmpty()) { throw new IllegalStateException("No servers available"); } Server leastConnectedServer = servers.get(0); for (Server server : servers) { if (server.activeConnections.get() < leastConnectedServer.activeConnections.get()) { leastConnectedServer = server; } } leastConnectedServer.activeConnections.incrementAndGet(); return leastConnectedServer; } public void releaseConnection(Server server) { server.activeConnections.decrementAndGet(); } public static void main(String[] args) { List<Server> servers = List.of( new Server("192.168.0.1"), new Server("192.168.0.2"), new Server("192.168.0.3") ); LeastConnectionsLoadBalancer loadBalancer = new LeastConnectionsLoadBalancer(servers); // 模拟10次请求 for (int i = 0; i < 10; i++) { Server server = loadBalancer.getNextServer(); System.out.println("Redirecting request to: " + server.ip); // 模拟处理完成后释放连接 loadBalancer.releaseConnection(server); } } }

java 如何实现 IP 哈希算法��具体实现

IP 哈希算法（IP Hash）是一种负载均衡算法，它根据客户端的 IP 地址分配请求，确保同一 IP 地址的请求始终分配到同一台服务器。

这样可以实现会话保持（session persistence）。

java

代码解读

复制代码

import java.util.List; import java.util.Objects; class Server { String ip; Server(String ip) { this.ip = ip; } } public class IPHashLoadBalancer { private List<Server> servers; public IPHashLoadBalancer(List<Server> servers) { this.servers = servers; } public Server getServer(String clientIP) { if (servers.isEmpty()) { throw new IllegalStateException("No servers available"); } int hash = Math.abs(Objects.hash(clientIP)); int serverIndex = hash % servers.size(); return servers.get(serverIndex); } public static void main(String[] args) { List<Server> servers = List.of( new Server("192.168.0.1"), new Server("192.168.0.2"), new Server("192.168.0.3") ); IPHashLoadBalancer loadBalancer = new IPHashLoadBalancer(servers); // 模拟请求 String[] clientIPs = { "192.168.1.10", "192.168.1.20", "192.168.1.30", "192.168.1.40", "192.168.1.50", "192.168.1.60" }; for (String clientIP : clientIPs) { Server server = loadBalancer.getServer(clientIP); System.out.println("Client IP: " + clientIP + " is routed to server: " + server.ip); } } }

java 如何实现一致性哈希算法

一致性哈希算法是一种常见的负载均衡算法，可以实现请求在服务器间的均匀分布，并且在增加或减少服务器时只影响少量请求的映射。

下面是一个基于 Java 的一致性哈希算法的实现。

java

代码解读

复制代码

import java.util.SortedMap; import java.util.TreeMap; class Server { String ip; Server(String ip) { this.ip = ip; } @Override public String toString() { return ip; } } public class ConsistentHashingLoadBalancer { private final SortedMap<Integer, Server> circle = new TreeMap<>(); private final int numberOfReplicas; public ConsistentHashingLoadBalancer(List<Server> servers, int numberOfReplicas) { this.numberOfReplicas = numberOfReplicas; for (Server server : servers) { add(server); } } private void add(Server server) { for (int i = 0; i < numberOfReplicas; i++) { int hash = hash(server.ip + i); circle.put(hash, server); } } public void remove(Server server) { for (int i = 0; i < numberOfReplicas; i++) { int hash = hash(server.ip + i); circle.remove(hash); } } public Server getServer(String key) { if (circle.isEmpty()) { return null; } int hash = hash(key); if (!circle.containsKey(hash)) { SortedMap<Integer, Server> tailMap = circle.tailMap(hash); hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey(); } return circle.get(hash); } private int hash(String key) { return key.hashCode() & 0x7fffffff; // 保证正数 } public static void main(String[] args) { List<Server> servers = List.of( new Server("192.168.0.1"), new Server("192.168.0.2"), new Server("192.168.0.3") ); ConsistentHashingLoadBalancer loadBalancer = new ConsistentHashingLoadBalancer(servers, 3); // 模拟请求 String[] clientKeys = { "client1", "client2", "client3", "client4", "client5", "client6" }; for (String key : clientKeys) { Server server = loadBalancer.getServer(key); System.out.println("Client key: " + key + " is routed to server: " + server); } // 增加一个服务器 System.out.println("\nAdding a new server 192.168.0.4\n"); loadBalancer.add(new Server("192.168.0.4")); for (String key : clientKeys) { Server server = loadBalancer.getServer(key); System.out.println("Client key: " + key + " is routed to server: " + server); } // 移除一个服务器 System.out.println("\nRemoving a server 192.168.0.2\n"); loadBalancer.remove(new Server("192.168.0.2")); for (String key : clientKeys) { Server server = loadBalancer.getServer(key); System.out.println("Client key: " + key + " is routed to server: " + server); } } }