后端负载均衡策略全解析：从原理到落地的实战指南

class RoundRobinBalancer:
    def __init__(self, servers):
        self.servers = servers
        self.index = 0  # 当前轮询到的位置

    def select(self):
        server = self.servers[self.index]
        self.index = (self.index + 1) % len(self.servers)
        return server

# 使用示例
servers = ["192.168.1.100:8080", "192.168.1.101:8080"]
balancer = RoundRobinBalancer(servers)
print(balancer.select())  # 输出192.168.1.100:8080
print(balancer.select())  # 输出192.168.1.101:8080

upstream backend {
    server 192.168.1.100 weight=3;  # 权重3
    server 192.168.1.101 weight=1;  # 权重1
}

import random

class WeightedRandomBalancer:
    def __init__(self, servers_with_weight):
        # servers_with_weight格式：[(server_addr, weight), ...]
        self.server_pool = []
        for server, weight in servers_with_weight:
            self.server_pool.extend([server] * weight)  # 按权重扩展列表

    def select(self):
        return random.choice(self.server_pool)

# 使用示例：Server A权重3，Server B权重1
balancer = WeightedRandomBalancer([("192.168.1.100", 3), ("192.168.1.101", 1)])
print(balancer.select())  # 75%概率输出192.168.1.100

package main

import (
    "fmt"
    "sync"
)

// Server 记录服务器地址和当前连接数
type Server struct {
    Addr     string
    ConnCount int
    mu       sync.Mutex
}

// IncrConn 增加连接数（线程安全）
func (s *Server) IncrConn() {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.ConnCount++
}

// DecrConn 减少连接数（线程安全）
func (s *Server) DecrConn() {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.ConnCount--
}

// LeastConnBalancer 最少连接数负载均衡器
type LeastConnBalancer struct {
    servers []*Server
}

// NewLeastConnBalancer 初始化负载均衡器
func NewLeastConnBalancer(servers []*Server) *LeastConnBalancer {
    return &LeastConnBalancer{servers: servers}
}

// Select 选择连接数最少的服务器
func (b *LeastConnBalancer) Select() *Server {
    var leastServer *Server
    minConn := int(^uint(0) >> 1) // 初始化为最大int值

    for _, s := range b.servers {
        s.mu.Lock()
        currentConn := s.ConnCount
        s.mu.Unlock()

        if currentConn < minConn {
            minConn = currentConn
            leastServer = s
        }
    }
    return leastServer
}

func main() {
    servers := []*Server{
        {Addr: "192.168.1.100", ConnCount: 50},
        {Addr: "192.168.1.101", ConnCount: 10}, // 连接数最少
        {Addr: "192.168.1.102", ConnCount: 80},
    }

    balancer := NewLeastConnBalancer(servers)
    selected := balancer.Select()
    fmt.Printf("选中服务器：%s（当前连接数：%d）
", selected.Addr, selected.ConnCount)
}

def ip_hash(server_list, client_ip):
    # 对IP进行哈希（简化版：将IP转为整数）
    ip_int = int(''.join(client_ip.split('.')))
    index = ip_int % len(server_list)
    return server_list[index]

# 使用示例
servers = ["192.168.1.100", "192.168.1.101", "192.168.1.102"]
client_ip = "192.168.0.5"
print(ip_hash(servers, client_ip))  # 每次调用都返回同一台服务器

package main

import (
    "fmt"
    "github.com/golang/groupcache/consistenthash"
)

func main() {
    // 创建一致性哈希环（虚拟节点数设为10，增加分布均匀性）
    ring := consistenthash.New(10, nil)

    // 添加服务器节点
    servers := []string{"192.168.1.100", "192.168.1.101", "192.168.1.102"}
    ring.Add(servers...)

    // 模拟请求哈希（比如用户ID的哈希值）
    requestKey := "user_123"
    selectedServer := ring.Get(requestKey)
    fmt.Printf("请求%s被分配到：%s
", requestKey, selectedServer)

    // 新增服务器节点
    ring.Add("192.168.1.103")
    newSelectedServer := ring.Get(requestKey)
    fmt.Printf("新增服务器后，请求%s被分配到：%s
", requestKey, newSelectedServer)
}