如何在不关闭TCP连接的前提下终止读取该连接的goroutine

Great question! 完全理解你的感受——Go的goroutine和I/O多路复用机制确实让同步风格的网络代码写起来得心应手，但有时候我们确实需要在保留连接的前提下，叫停那些阻塞在conn.Read()上的goroutine。下面给你分享几种实用的方案：

1. 使用context.Context实现可取消的读取 #

这是Go生态里最惯用的方式，尤其适合需要统一管理多个goroutine生命周期的场景。核心思路是通过定期设置读取超时，让conn.Read()周期性返回，然后检查context是否已被取消：

import (
    "context"
    "net"
    "time"
)

func readWithContext(ctx context.Context, conn net.Conn, buf []byte) (int, error) {
    for {
        // 设置1秒的读取超时，让Read不会一直阻塞
        if err := conn.SetReadDeadline(time.Now().Add(1 * time.Second)); err != nil {
            return 0, err
        }

        n, err := conn.Read(buf)
        // 重置超时，避免影响后续的连接操作
        if err := conn.SetReadDeadline(time.Time{}); err != nil {
            return n, err
        }

        // 先检查context是否已取消，优先响应终止信号
        select {
        case <-ctx.Done():
            return 0, ctx.Err()
        default:
        }

        // 处理Read的结果
        if err != nil {
            // 如果是超时错误，继续循环等待下一次检查
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                continue
            }
            return n, err
        }
        return n, nil
    }
}

使用时，你只需要创建一个带取消函数的context，在需要终止goroutine时调用cancel()即可：

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

go func() {
    buf := make([]byte, 1024)
    _, err := readWithContext(ctx, conn, buf)
    // 这里会收到context.Canceled错误，goroutine退出
}()

// 当需要终止时调用cancel
cancel()

2. 使用终止通道（Stop Channel）+ 超时检查 #

如果不需要context的复杂功能，也可以用一个简单的通道作为终止信号，配合定期超时让goroutine有机会检查这个信号：

import (
    "errors"
    "net"
    "time"
)

func readWithStopSignal(conn net.Conn, buf []byte, stopChan <-chan struct{}) (int, error) {
    for {
        conn.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
        n, err := conn.Read(buf)
        conn.SetReadDeadline(time.Time{})

        // 优先检查终止信号
        select {
        case <-stopChan:
            return 0, errors.New("read operation stopped")
        default:
        }

        if err != nil {
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                continue
            }
            return n, err
        }
        return n, nil
    }
}

使用示例：

stopChan := make(chan struct{})
go func() {
    buf := make([]byte, 1024)
    _, err := readWithStopSignal(conn, buf, stopChan)
    // 收到终止信号后退出
}()

// 需要终止时关闭通道
close(stopChan)

3. TCP连接专属：使用CloseRead()关闭读端 #

如果你的连接是TCP类型，可以将net.Conn类型断言为*net.TCPConn，然后调用CloseRead()方法。这个方法只会关闭连接的读端，阻塞在Read()的goroutine会立即返回io.EOF错误，但连接的写端仍然可以正常使用：

tcpConn, ok := conn.(*net.TCPConn)
if ok {
    // 关闭读端，不会影响写操作
    if err := tcpConn.CloseRead(); err != nil {
        // 处理错误
    }
    // 此时原来阻塞在conn.Read()的goroutine会收到EOF并退出
}

这种方式非常轻量，适合只需要终止读goroutine、同时还要保留写能力的场景。

内容的提问来源于stack exchange，提问作者darxtrix