GitHub_Trending/in/interviews：服务发现与负载均衡
项目地址: https://gitcode.com/GitHub_Trending/in/interviews 你还在为分布式系统面试焦头烂额？一文掌握服务发现与负载均衡核心算法
在分布式系统架构中，服务发现（Service Discovery）与负载均衡（Load Balancing）是保障系统高可用、高并发的两大核心支柱。无论是微服务架构下的服务注册与发现，还是大型分布式系统中的流量分发策略，掌握这两类关键技术不仅是面试高频考点，更是构建可靠分布式系统的必备能力。
读完本文你将获得：
- 服务发现三大核心模式的实现原理与代码示例
- 负载均衡算法的数学模型与性能对比
- 从LeetCode真题到工程实践的完整知识链路
- 高频面试题的最优解题思路与代码实现
服务发现：分布式系统的"通讯录"
服务发现核心挑战
在单体架构向微服务架构演进过程中，服务实例的动态性（扩缩容、故障替换）导致传统静态配置方式失效。服务发现机制通过维护"服务名-网络地址"的映射关系，解决了分布式系统中的服务定位问题。
三种服务发现模式对比
| 模式 | 实现复杂度 | 网络开销 | 容错能力 | 典型应用 |
|---|---|---|---|---|
| 客户端发现 | 中 | 低（直连服务） | 需客户端实现重试逻辑 | Netflix Eureka + Ribbon |
| 服务端发现 | 高（需负载均衡器） | 中（多一跳转发） | 集中式容错处理 | Kubernetes Service |
| 基于DNS | 低 | 高（DNS缓存问题） | 依赖DNS服务器可用性 | 早期微服务架构 |
客户端发现模式Java实现
以LeetCode经典设计题"LRU缓存"为基础，实现一个简化的服务注册中心：
public class ServiceRegistry {
private final LRUCache<String, List<String>> serviceCache;
public ServiceRegistry(int capacity) {
this.serviceCache = new LRUCache<>(capacity);
}
// 服务注册
public void register(String serviceName, String instanceAddress) {
serviceCache.putIfAbsent(serviceName, new ArrayList<>());
List<String> instances = serviceCache.get(serviceName);
if (!instances.contains(instanceAddress)) {
instances.add(instanceAddress);
}
}
// 服务发现
public List<String> discover(String serviceName) {
return serviceCache.getOrDefault(serviceName, Collections.emptyList());
}
// 服务下线
public void deregister(String serviceName, String instanceAddress) {
List<String> instances = serviceCache.get(serviceName);
if (instances != null) {
instances.remove(instanceAddress);
if (instances.isEmpty()) {
serviceCache.remove(serviceName);
}
}
}
}
负载均衡：流量分发的艺术
负载均衡算法性能对比
负载均衡通过合理分发请求，避免单点过载，提高系统吞吐量。以下是五种经典负载均衡算法的时间复杂度与适用场景分析：
一致性哈希算法实现
针对分布式缓存场景，一致性哈希解决了传统哈希算法在节点变化时大量缓存失效的问题：
public class ConsistentHash<T> {
private final SortedMap<Integer, T> circle = new TreeMap<>();
private final int numberOfReplicas; // 虚拟节点数量
public ConsistentHash(int numberOfReplicas, Collection<T> nodes) {
this.numberOfReplicas = numberOfReplicas;
for (T node : nodes) {
add(node);
}
}
// 添加节点（含虚拟节点）
public void add(T node) {
for (int i = 0; i < numberOfReplicas; i++) {
circle.put(hash(node.toString() + i), node);
}
}
// 移除节点
public void remove(T node) {
for (int i = 0; i < numberOfReplicas; i++) {
circle.remove(hash(node.toString() + i));
}
}
// 获取对象映射的节点
public T get(Object key) {
if (circle.isEmpty()) {
return null;
}
int hash = hash(key.toString());
if (!circle.containsKey(hash)) {
// 顺时针查找下一个节点
SortedMap<Integer, T> tailMap = circle.tailMap(hash);
hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
}
return circle.get(hash);
}
// FNV1哈希算法
private int hash(String key) {
final int p = 16777619;
int hash = (int) 2166136261L;
for (int i = 0; i < key.length(); i++) {
hash = (hash ^ key.charAt(i)) * p;
}
hash += hash << 13;
hash ^= hash >> 7;
hash += hash << 3;
hash ^= hash >> 17;
hash += hash << 5;
return Math.abs(hash);
}
}
LeetCode真题实战：一致性哈希表设计
LeetCode 146. LRU缓存机制是实现服务注册中心的基础组件，其核心在于维护近期使用的服务实例信息，淘汰长期未使用的条目。
class LRUCache {
private final Map<Integer, Node> cache;
private final DoubleLinkedList list;
private final int capacity;
public LRUCache(int capacity) {
this.capacity = capacity;
cache = new HashMap<>(capacity);
list = new DoubleLinkedList();
}
public int get(int key) {
if (!cache.containsKey(key)) return -1;
Node node = cache.get(key);
list.moveToHead(node);
return node.value;
}
public void put(int key, int value) {
if (cache.containsKey(key)) {
Node node = cache.get(key);
node.value = value;
list.moveToHead(node);
} else {
Node newNode = new Node(key, value);
cache.put(key, newNode);
list.addToHead(newNode);
if (cache.size() > capacity) {
Node tail = list.removeTail();
cache.remove(tail.key);
}
}
}
// 双向链表实现
static class DoubleLinkedList {
private final Node head, tail;
public DoubleLinkedList() {
head = new Node(0, 0);
tail = new Node(0, 0);
head.next = tail;
tail.prev = head;
}
public void addToHead(Node node) {
node.next = head.next;
node.prev = head;
head.next.prev = node;
head.next = node;
}
public void removeNode(Node node) {
node.prev.next = node.next;
node.next.prev = node.prev;
}
public void moveToHead(Node node) {
removeNode(node);
addToHead(node);
}
public Node removeTail() {
Node res = tail.prev;
removeNode(res);
return res;
}
}
static class Node {
int key, value;
Node prev, next;
public Node(int key, int value) {
this.key = key;
this.value = value;
}
}
}
负载均衡：流量分发的数学艺术
负载均衡算法性能分析
负载均衡算法的选择直接影响系统的吞吐量、响应时间和容错能力。以下是五种常用算法的性能对比：
加权轮询算法实现
针对不同性能的服务器实例，加权轮询算法通过分配不同权重实现流量差异化分发：
public class WeightedRoundRobin {
private final List<Server> servers;
private int currentIndex = -1;
private int currentWeight = 0;
private int maxWeight;
private int gcdWeight;
public WeightedRoundRobin(List<Server> servers) {
this.servers = servers;
this.maxWeight = getMaxWeight(servers);
this.gcdWeight = getGCD(servers);
}
public Server select() {
while (true) {
currentIndex = (currentIndex + 1) % servers.size();
if (currentIndex == 0) {
currentWeight -= gcdWeight;
if (currentWeight <= 0) {
currentWeight = maxWeight;
if (currentWeight == 0) {
return null;
}
}
}
if (servers.get(currentIndex).getWeight() >= currentWeight) {
return servers.get(currentIndex);
}
}
}
private int getMaxWeight(List<Server> servers) {
return servers.stream()
.mapToInt(Server::getWeight)
.max()
.orElse(0);
}
private int getGCD(List<Server> servers) {
return servers.stream()
.mapToInt(Server::getWeight)
.reduce(this::gcd)
.orElse(0);
}
private int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
public static class Server {
private final String ip;
private final int weight;
public Server(String ip, int weight) {
this.ip = ip;
this.weight = weight;
}
public String getIp() {
return ip;
}
public int getWeight() {
return weight;
}
}
}
最小连接数算法实现
最小连接数算法通过实时监控服务器当前连接数，将新请求分发到连接数最少的实例：
public class LeastConnections {
private final List<Server> servers;
public LeastConnections(List<Server> servers) {
this.servers = servers;
}
public Server select() {
return servers.stream()
.min(Comparator.comparingInt(Server::getConnections))
.orElse(null);
}
public void incrementConnections(Server server) {
server.setConnections(server.getConnections() + 1);
}
public void decrementConnections(Server server) {
if (server.getConnections() > 0) {
server.setConnections(server.getConnections() - 1);
}
}
public static class Server {
private final String ip;
private final int weight;
private int connections;
public Server(String ip, int weight) {
this.ip = ip;
this.weight = weight;
this.connections = 0;
}
// Getters and setters
public String getIp() { return ip; }
public int getWeight() { return weight; }
public int getConnections() { return connections; }
public void setConnections(int connections) { this.connections = connections; }
}
}
从算法到架构：分布式系统的面试考点
CAP定理在服务发现中的应用
服务发现系统面临CAP定理的权衡选择：
- Consistency（一致性）：所有节点看到相同的服务列表
- Availability（可用性）：即使部分节点故障，仍能提供服务发现
- Partition tolerance（分区容错性）：网络分区时系统仍能工作
Eureka选择AP（可用性优先）策略，通过最终一致性保证服务可用；而ZooKeeper选择CP（一致性优先）策略，适合对数据一致性要求高的场景。
面试高频题：设计一个分布式服务发现系统
结合本文所学知识，完整的服务发现系统应包含以下组件：
- 注册中心：维护服务注册表（可基于LRUCache实现）
- 服务注册/注销：服务实例启动/关闭时更新注册表
- 健康检查：定期探测服务实例可用性
- 服务发现接口：提供客户端查询服务列表
- 负载均衡：客户端获取服务列表后的流量分发策略
public class DistributedServiceDiscovery {
private final ServiceRegistry registry;
private final HealthChecker healthChecker;
private final LoadBalancer loadBalancer;
public DistributedServiceDiscovery(int cacheCapacity) {
this.registry = new ServiceRegistry(cacheCapacity);
this.healthChecker = new HealthChecker(registry);
this.loadBalancer = new LoadBalancer();
// 启动健康检查线程
new Thread(healthChecker).start();
}
// 服务注册
public void registerService(String serviceName, String host, int port) {
String address = host + ":" + port;
registry.register(serviceName, address);
}
// 服务发现与负载均衡
public String discoverService(String serviceName) {
List<String> addresses = registry.discover(serviceName);
if (addresses.isEmpty()) {
throw new RuntimeException("No available instances for service: " + serviceName);
}
return loadBalancer.select(addresses);
}
// 其他辅助方法...
}
总结与展望
服务发现与负载均衡作为分布式系统的基础设施，其设计思想贯穿了数据结构（哈希表、链表）、算法（一致性哈希、加权轮询）和架构设计（CAP定理、最终一致性）等多个计算机科学领域。
从LeetCode的LRU缓存题到生产环境的Eureka注册中心，从简单轮询到自适应负载均衡，技术的演进始终围绕着"如何在动态变化的分布式环境中高效定位并调用服务"这一核心问题。
掌握这些核心技术不仅能帮助你在面试中脱颖而出，更能为构建高可用、高并发的分布式系统打下坚实基础。建议结合本文代码示例，实现一个简化版服务发现系统，深入理解其内部工作原理。
收藏本文，下次面试前复习这些核心知识点，祝你轻松拿下分布式系统相关岗位！
下期预告：分布式事务的四种实现方案与性能对比
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
