Go / 系统课时

给连接处理加并发上限

给连接处理加并发上限

网络服务不能把每个新连接都无条件交给新的 goroutine。连接突增时,真正先耗尽的往往是数据库连接、文件描述符、内存或下游容量。本节用带缓冲 channel 构造并发闸门,让连接只有取得许可后才能进入处理阶段。

学习目标

  • 用带缓冲 channel 限制同时执行的连接处理数量
  • 理解为什么许可应在启动处理 goroutine 前获取
  • 正确释放许可,并为过载场景选择等待或拒绝策略

把并发数量变成明确资源边界

Go 创建 goroutine 的成本较低,但低成本不等于无限容量。假设服务能同时承受 200 个数据库事务,即使进来了 5000 个 TCP 连接,也不应同时启动 5000 个会访问数据库的处理流程。

带缓冲 channel 可以直接表示固定数量的许可。容量为 2 时,最多只有两个处理任务能同时持有令牌;第三个任务向 channel 发送令牌时会阻塞,直到已有任务释放令牌。

连接进入并发闸门后的处理流程

用 channel 实现连接许可

下面用 net.Pipe 创建 5 组内存连接,模拟已经被服务端接受的连接。并发许可容量设为 2,并记录整个运行期间真正同时进入处理函数的最大数量。

go
package main

import (
    "fmt"
    "net"
    "sync"
    "sync/atomic"
    "time"
)

func updateMax(max *int64, current int64) {
    for {
        old := atomic.LoadInt64(max)
        if current <= old || atomic.CompareAndSwapInt64(max, old, current) {
            return
        }
    }
}

func main() {
    semaphore := make(chan struct{}, 2)
    var wg sync.WaitGroup
    var active int64
    var maxActive int64

    for i := 0; i < 5; i++ {
        serverConn, clientConn := net.Pipe()

        // 先获取许可再创建处理 goroutine,避免等待任务本身无限增长。
        semaphore <- struct{}{}
        wg.Add(1)

        go func(conn net.Conn) {
            defer wg.Done()
            defer conn.Close()
            defer func() { <-semaphore }()

            current := atomic.AddInt64(&active, 1)
            updateMax(&maxActive, current)

            // 模拟连接处理占用下游资源。
            time.Sleep(80 * time.Millisecond)
            atomic.AddInt64(&active, -1)
        }(serverConn)

        clientConn.Close()
    }

    wg.Wait()
    fmt.Printf("max concurrent: %d\n", atomic.LoadInt64(&maxActive))
}

预期输出

text
max concurrent: 2

这里最重要的不是 channel 本身,而是获取许可的位置。若先启动 goroutine,再让 goroutine 内部等待许可,并发处理虽然仍然只有 2 个,但突发流量仍可能创建成千上万个等待 goroutine,资源边界就只限制了业务处理,没有限制排队成本。

放进真实的 Accept 循环

真实 TCP 服务通常在 Accept 成功后、启动连接处理 goroutine 前获取许可。此时处理达到上限后,接受循环会停在许可获取处,不再无限创建新的处理任务。

片段示例,依赖已经创建好的 listener net.Listener 与 handleConn func(net.Conn):

go
semaphore := make(chan struct{}, 200)

for {
    conn, err := listener.Accept()
    if err != nil {
        return err
    }

    semaphore <- struct{}{}
    go func(c net.Conn) {
        defer func() { <-semaphore }()
        defer c.Close()
        handleConn(c)
    }(conn)
}

这段配置的生效行为是:最多 200 个 handleConn 同时执行。验证时可以在处理函数入口和出口维护一个原子计数器,压测后确认观测到的峰值没有超过 200。

等待还是快速拒绝

阻塞式获取许可适合允许短暂排队的服务。如果过载后继续等待会拖长请求超时,可以用非阻塞 select 实现快速拒绝:许可可用就进入处理,否则关闭刚接受的连接或返回协议层的过载响应。

选择上限时不要根据“机器能创建多少 goroutine”决定,而应从最紧张的共享资源反推,例如数据库连接池容量、每连接内存、下游 QPS 或单机可接受延迟。并发闸门的价值,就是把这些隐含限制变成代码中可观察、可测试的边界。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

给连接处理加并发上限

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通