Go程序Unix套接字读取遇EAGAIN冻结，如何捕获错误优雅退出？

问题背景 #

使用以下Go代码连接Unix域套接字，发送请求后读取响应时程序出现冻结：

d := net.Dialer{Timeout: time.Second * 5}
c, err := d.Dial("unix", CONFIG.ServiceSocket.Path)
if err != nil {
    handleFatalError(err, errorString)
}
defer c.Close()

// send message
message := fmt.Sprintf("{\"action\":\"%s\"}", *Arguments.Action)
_, err = c.Write([]byte(message))
if err != nil {
    var errorString = fmt.Sprintf("Write error: %s", err)
    handleFatalError(err, errorString)
}

// read response
buf := make([]byte, CONFIG.ServiceSocket.Buffer)
n, err := c.Read(buf[:])
if err != nil {
    var errorString = fmt.Sprintf("Read error: %s", err)
    handleFatalError(err, errorString)
}

对应的系统调用序列显示，read返回EAGAIN错误后，程序进入epoll_pwait无限阻塞：

socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0) = 3
connect(3, {sa_family=AF_UNIX, sun_path="/var/run/dhcomms/dispatcher.sock"}, 35) = 0
epoll_ctl(4, EPOLL_CTL_ADD, 3, {EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLET, {u32=74057432, u64=139805554509528}}) = 0
getsockname(3, {sa_family=AF_UNIX}, [112->2]) = 0
getpeername(3, {sa_family=AF_UNIX, sun_path="/var/run/dhcomms/dispatcher.sock"}, [112->35]) = 0
write(3, "{\"action\":\"status\"}", 19) = 19
read(3, 0xc000100000, 1048576)          = -1 EAGAIN (Resource temporarily unavailable)
futex(0x6aafd8, FUTEX_WAKE_PRIVATE, 1)  = 1
futex(0x6aaed8, FUTEX_WAKE_PRIVATE, 1)  = 1
epoll_pwait(4, [{EPOLLOUT, {u32=74057432, u64=139805554509528}}], 128, 0, NULL, 0) = 1
epoll_pwait(4, 

解决方案 #

Go标准库的net.Conn会将套接字设为非阻塞模式，当Read遇到EAGAIN时，runtime会自动通过epoll等待数据，导致程序无限阻塞。要避免这种情况并优雅关闭，可通过以下两种方式实现：

方式1：设置读取超时 #

在调用Read前设置连接的读取超时，超时后会返回明确的超时错误，而非无限等待：

import (
    "net"
    "fmt"
    "time"
    "log"
    "os"
    // 其他依赖...
)

d := net.Dialer{Timeout: time.Second * 5}
c, err := d.Dial("unix", CONFIG.ServiceSocket.Path)
if err != nil {
    handleFatalError(err, errorString)
}
// 确保连接最终被关闭
defer func() {
    if err := c.Close(); err != nil {
        log.Printf("Failed to close connection: %v", err)
    }
}()

// 发送消息
message := fmt.Sprintf("{\"action\":\"%s\"}", *Arguments.Action)
_, err = c.Write([]byte(message))
if err != nil {
    errorString := fmt.Sprintf("Write error: %s", err)
    handleFatalError(err, errorString)
}

// 设置读取超时（例如5秒）
err = c.SetReadDeadline(time.Now().Add(5 * time.Second))
if err != nil {
    errorString := fmt.Sprintf("Set read deadline error: %s", err)
    handleFatalError(err, errorString)
}

// 读取响应
buf := make([]byte, CONFIG.ServiceSocket.Buffer)
n, err := c.Read(buf[:])
if err != nil {
    // 判断是否为超时或临时错误（包含EAGAIN场景）
    if netErr, ok := err.(net.Error); ok && (netErr.Timeout() || netErr.Temporary()) {
        log.Printf("Read timeout or temporary error: %v", err)
        // 优雅退出程序
        os.Exit(1)
    } else {
        errorString := fmt.Sprintf("Read error: %s", err)
        handleFatalError(err, errorString)
    }
}
// 处理正常读取到的数据...

方式2：手动处理底层套接字的EAGAIN #

如果需要直接捕获EAGAIN错误，可通过syscall包获取底层文件描述符，手动进行非阻塞读取：

import (
    "net"
    "syscall"
    "fmt"
    "log"
    "os"
    // 其他依赖...
)

d := net.Dialer{Timeout: time.Second * 5}
c, err := d.Dial("unix", CONFIG.ServiceSocket.Path)
if err != nil {
    handleFatalError(err, errorString)
}
defer func() {
    if err := c.Close(); err != nil {
        log.Printf("Failed to close connection: %v", err)
    }
}()

// 发送消息
message := fmt.Sprintf("{\"action\":\"%s\"}", *Arguments.Action)
_, err = c.Write([]byte(message))
if err != nil {
    errorString := fmt.Sprintf("Write error: %s", err)
    handleFatalError(err, errorString)
}

// 获取Unix套接字的底层文件描述符
unixConn, ok := c.(*net.UnixConn)
if !ok {
    handleFatalError(fmt.Errorf("not a UnixConn"), "Invalid connection type")
}
connFile, err := unixConn.File()
if err != nil {
    handleFatalError(err, fmt.Sprintf("Get connection file error: %s", err))
}
defer connFile.Close()
fd := int(connFile.Fd())

// 确保套接字为非阻塞模式
err = syscall.SetNonblock(fd, true)
if err != nil {
    handleFatalError(err, fmt.Sprintf("Set nonblock error: %s", err))
}

// 手动读取数据
buf := make([]byte, CONFIG.ServiceSocket.Buffer)
n, err := syscall.Read(fd, buf)
if err != nil {
    if err == syscall.EAGAIN || err == syscall.EWOULDBLOCK {
        log.Println("Resource temporarily unavailable, closing connection gracefully")
        os.Exit(1)
    } else {
        handleFatalError(err, fmt.Sprintf("Read error: %s", err))
    }
}
// 处理正常读取到的数据...

说明 #

• 方式1更符合Go的惯用写法，无需直接操作系统调用，推荐优先使用。
• 设置超时后，即使遇到EAGAIN，runtime也会在超时时间到后返回错误，避免无限阻塞。
• 优雅关闭时，务必调用c.Close()释放套接字资源，防止资源泄漏。

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