Go语言实战：从零实现最少连接数负载均衡器

阿澈

发布时间：2026-10-15| 6人浏览过

原创

本文详解如何在Go语言中从零构建一个轻量级负载均衡器。通过对比轮询、加权轮询与最少连接数等算法，提供基于"最少活跃连接"原则的完整实现代码，包含后端接口定义与并发控制方法。

负载均衡核心逻辑

当单台服务器无法承受海量并发请求时，增加服务器数量成为必然选择。此时，如何高效地将流量分配到多个后端节点，就是负载均衡器（Load Balancer）解决的核心问题。其基本作用位于所有后端服务前端，接收用户请求后，依据特定算法将请求精准转发至目标服务器，从而保障服务的稳定性与高可用性。

常见转发策略

1. 轮询算法 (Round Robin)
这是最基础的分配方式。它按照固定顺序将请求依次分发给每台服务器。这种方式不关注服务器的当前负载或处理能力差异，仅判断服务是否可用。适用于各服务器硬件配置及处理能力相近的场景。

type roundRobin struct {
    targets []*url.URL
    index   int
}

func (rr *roundRobin) nextTarget() *url.URL {
    target := rr.targets[rr.index]
    // 取模计算索引，实现循环轮换
    rr.index = (rr.index + 1) % len(rr.targets)
    return target
}

func (rr *roundRobin) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    target := rr.nextTarget()
    // 使用标准库反向代理转发
    proxy := httputil.NewSingleHostReverseProxy(target)
    proxy.ServeHTTP(w, r)
}

2. 加权轮询算法 (Weighted Round Robin)
如果后端服务器性能存在差异（例如Server A的性能是Server B的两倍），可以使用权重算法让高性能机器处理更多流量。

type serverWeight int

const (
	ServerA serverWeight = 6 // 10个请求中分6个
	ServerB serverWeight = 3 // 10个请求中分3个
	ServerC serverWeight = 1 // 10个请求中分1个
)

3. 最少连接数算法 (Least Connections)
该算法优先选择当前活跃连接数最低的服务器进行转发。这比轮询更贴合实际业务状态，能更好地避免某台服务器过载。进阶版会引入权重：被选中的服务器应满足其`连接数/权重`比值最小。

Go实战：最少连接负载均衡器

在实际生产环境中，“最少连接数”往往是最合理的默认调度策略。下面展示如何使用Go语言实现这一核心功能。

第1步：设计后端抽象层

为了让负载均衡器具备通用性，我们首先定义一个Backend接口。它将具体的服务器地址和连接监控状态封装起来：

package main

import (
    "net/http"
    "net/http/httputil"
    "net/url"
    "sync"
    "math"
)

// Backend 定义了后端服务的统一接口
type Backend interface {
    GetURL() string           // 获取转发目标地址
    GetConnections() int      // 获取当前活跃连接数
}

第2步：定义调度器结构体

创建leastConn结构体来管理后端集群。由于Go的Goroutine并发特性，必须使用sync.Mutex锁保护共享资源（如连接计数统计），以防在遍历节点时发生竞态条件。

// leastConn 最少连接数负载均衡器
type leastConn struct {
    targets []Backend
    mutex   sync.Mutex
}

第3步：实现节点选择算法

在leastTarget方法中，遍历所有后端节点。每次检查连接数前加锁，确保获取的数据准确，找到连接数最小的节点作为目标。
**注意**：如果存在连接数完全一致的多个服务器，以下代码默认选中第一个遇到的节点；在生产场景中可加入随机化选择以进一步分散热点。

func (lc *leastConn) leastTarget() Backend {
    var target Backend
    minConns := math.MaxInt32

    for _, t := range lc.targets {
        // 获取单个节点的连接数据时加锁
        lc.mutex.Lock()
        conns := t.GetConnections()
        lc.mutex.Unlock()

        // 维护最小值
        if conns < minConns {
            minConns = conns
            target = t
        }
    }
    return target
}

第4步：挂载HTTP处理路由

最后，让负载均衡器实现http.Handler接口。利用Go标准库的httputil.NewSingleHostReverseProxy，可以将请求反向代理到选定好的目标服务器，并原样返回响应。

func (lc *leastConn) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 1. 挑选最优后端
    target := lc.leastTarget()
    
    // 2. 设置反向代理
    proxy := httputil.NewSingleHostReverseProxy(
        &url.URL{Scheme: "http", Host: target.GetURL()},
    )
    
    // 3. 执行转发
    proxy.ServeHTTP(w, r)
}