Go / 系统课时

一条连接对应一个 goroutine 吗

一条连接对应一个 goroutine 吗

Go TCP 服务常写成 Accept 一个连接就启动一个 goroutine,但这是一种常用并发模型,不是协议或运行时的硬性规定。本节要分清“连接、goroutine、操作系统线程”三者的关系,并给出连接上限、超时和退出条件,避免轻量 goroutine 演变成长期泄漏。

学习目标

  • 理解为什么“一连接一 goroutine”不等于“一连接一线程”
  • 识别连接 goroutine 的真实资源成本和典型泄漏路径
  • 用连接上限与读写超时给并发模型加上可验证的边界

先分清连接、goroutine 和线程

最常见的写法是主 goroutine 负责 Accept,每拿到一个 net.Conn 就启动一个连接 goroutine。连接 goroutine 在网络读取上阻塞时,Go 运行时可借助 netpoller 等待套接字就绪,而不需要让一个操作系统线程一直陪着它阻塞。

一连接一 goroutine 与 Go netpoller 的关系

所以“一连接一 goroutine”通常是可以扩展的,但不代表连接成本接近零。每个连接仍会占用文件描述符、内核 socket 缓冲区、net.Conn 对象、goroutine 栈、定时器以及业务状态;这些资源中的任意一个都可能先达到上限。

为什么这种模型仍然常用

它最大的优点是代码结构直接:一个 goroutine 顺序处理一个连接的读取、解析和写回,错误处理与连接生命周期都集中在同一条控制流里。对于大量 I/O 等待、每个连接业务较轻的服务,这种模型通常比手写事件循环更容易保证正确性。

但不要把所有工作都塞进连接 goroutine。CPU 密集计算、慢数据库调用或无界队列会延长单个 goroutine 的存活时间,也会把“连接数”放大成更多下游并发。连接层最好只做协议 I/O、轻量解析和受控的任务分发。

给一连接一 goroutine 加资源边界

下面的 Echo 服务仍然为每条连接创建 goroutine,但同时限制最多 1024 条活动连接,并给每次读取和写入设置期限。连接空闲过久、客户端不再读取响应或处理函数正常结束时,goroutine 都能离开。

go
package main

import (
    "errors"
    "fmt"
    "io"
    "log"
    "net"
    "time"
)

func handleConn(conn net.Conn) {
    defer conn.Close()
    buf := make([]byte, 4096)

    for {
        // 空闲连接不会永久占住 goroutine。
        _ = conn.SetReadDeadline(time.Now().Add(30 * time.Second))
        n, err := conn.Read(buf)

        if n > 0 {
            // 写端也要有上限,避免对端不读数据时永久阻塞。
            _ = conn.SetWriteDeadline(time.Now().Add(5 * time.Second))
            if _, writeErr := conn.Write(buf[:n]); writeErr != nil {
                return
            }
        }

        if err != nil {
            if errors.Is(err, io.EOF) {
                return
            }
            var netErr net.Error
            if errors.As(err, &netErr) && netErr.Timeout() {
                return
            }
            return
        }
    }
}

func main() {
    ln, err := net.Listen("tcp", "127.0.0.1:9001")
    if err != nil {
        log.Fatal(err)
    }
    defer ln.Close()

    slots := make(chan struct{}, 1024)
    fmt.Println("listening on 127.0.0.1:9001")

    for {
        conn, err := ln.Accept()
        if err != nil {
            log.Fatal(err)
        }

        select {
        case slots <- struct{}{}:
            go func(c net.Conn) {
                defer func() { <-slots }()
                handleConn(c)
            }(conn)
        default:
            _ = conn.Close()
        }
    }
}

运行服务:

bash
go run main.go

预期结果(服务继续保持运行):

text
listening on 127.0.0.1:9001

再用支持 -N 的 OpenBSD netcat 发送一行数据:

bash
printf 'ping\n' | nc -N 127.0.0.1 9001

预期输出:

text
ping

如果本机 nc 不支持 -N,应根据 nc -h 使用当前实现提供的等价关闭选项;这不影响服务端的一连接一 goroutine 模型。

goroutine 泄漏通常怎么发生

最典型的情况是处理函数永久阻塞在 Read:对端既不发数据也不关闭连接,而服务端又没有 deadline。此时即使函数里写了 defer conn.Close() 也没有帮助,因为 defer 只有在函数返回时才会执行。

第二类泄漏来自业务协作,例如连接 goroutine 向无人消费的 channel 发送数据、等待永远不返回的下游任务,或服务关闭时只关闭 listener,却没有让存量连接退出。修复思路都是给“等待”加边界:网络 I/O 用 deadline,队列要有容量和取消路径,服务退出时要主动关闭或取消活动连接。

什么时候不要机械坚持一连接一 goroutine

如果连接数极大且大部分长期空闲,同时内存预算非常紧,应先压测 goroutine、socket 缓冲区和文件描述符的实际占用,再决定是否值得引入更底层的事件循环或 poller。不要只因为“连接很多”就提前放弃标准 net 模型。

另外,复杂协议也未必严格一对一:有的连接会拆成独立读写 goroutine,有的会把 CPU 工作交给受限 worker pool。应把“连接生命周期清晰、资源有上限、退出可验证”当作目标,而不是把 goroutine 数量本身当作设计原则。

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

目录与阅读设置

阅读设置

17

记录一个想法

一条连接对应一个 goroutine 吗

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

登录哪都通