Question

我正在尝试编写一个基于套接字的简单go服务器。我只是想知道如何连接。下面的内容知道什么时候停止阅读。（注意：这不是我的代码，我以Unix Sockets in Go为例复制了代码）

package main

import (
  "log"
  "net"
)

func echoServer(c net.Conn) {
  for {
    buf := make([]byte, 512)
    nr, err := c.Read(buf)
    if err != nil {
        return
    }

    data := buf[0:nr]
    println("Server got:", string(data))
    _, err = c.Write(data)
    if err != nil {
        log.Fatal("Write: ", err)
    }
  }
}

func main() {
  l, err := net.Listen("unix", "/tmp/echo.sock")
  if err != nil {
    log.Fatal("listen error:", err)
  }

  for {
    fd, err := l.Accept()
    if err != nil {
        log.Fatal("accept error:", err)
    }

    go echoServer(fd)
  }
 }

是EOF字符还是其他？如果有人可以将我指向链接官方go docs，那将非常有帮助。谢谢。

Answer 1

这是Read上默认net.Conn.Read方法的实现：

// Read implements the Conn Read method.
func (c *conn) Read(b []byte) (int, error) {
    if !c.ok() {
        return 0, syscall.EINVAL
    }
    n, err := c.fd.Read(b)
    if err != nil && err != io.EOF {
        err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
    }
    return n, err
}

这是上面函数中调用的c.fd.Read(b)的实现：

func (fd *netFD) Read(p []byte) (n int, err error) {
    if err := fd.readLock(); err != nil {
        return 0, err
    }
    defer fd.readUnlock()
    if len(p) == 0 {
        // If the caller wanted a zero byte read, return immediately
        // without trying. (But after acquiring the readLock.) Otherwise
        // syscall.Read returns 0, nil and eofError turns that into
        // io.EOF.
        // TODO(bradfitz): make it wait for readability? (Issue 15735)
        return 0, nil
    }
    if err := fd.pd.prepareRead(); err != nil {
        return 0, err
    }
    if fd.isStream && len(p) > 1<<30 {
        p = p[:1<<30]
    }
    for {
        n, err = syscall.Read(fd.sysfd, p)
        if err != nil {
            n = 0
            if err == syscall.EAGAIN {
                if err = fd.pd.waitRead(); err == nil {
                    continue
                }
            }
        }
        err = fd.eofError(n, err)
        break
    }
    if _, ok := err.(syscall.Errno); ok {
        err = os.NewSyscallError("read", err)
    }
    return
}

因此，是的，EOF将使其停止读取。但是其他很多非空错误也会如此。

Answer 2

当其基础实现遇到任何错误时，它将停止读取。错误可能是实际的I / O错误，或者可能是操作系统信号连接被io.EOF关闭，或者可能是超时，等等。

golang的net.Conn.Read如何停止读取？

2 个答案: