靶病变; DR：
在使用os.File.Fd()后对文件使用syscall.SetNonblock(fd.Fd(), true)
这是由于readin golang UNIX的实现：

func (fd *FD) Read(p []byte) (int, 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 which looks like
        // io.EOF.
        // TODO(bradfitz): make it wait for readability? (Issue 15735)
        return 0, nil
    }
    if err := fd.pd.prepareRead(fd.isFile); err != nil {
        return 0, err
    }
    if fd.IsStream && len(p) > maxRW {
        p = p[:maxRW]
    }
    for {
        n, err := ignoringEINTRIO(syscall.Read, fd.Sysfd, p)
        if err != nil {
            n = 0
            if err == syscall.EAGAIN && fd.pd.pollable() {
                if err = fd.pd.waitRead(fd.isFile); err == nil {
                    continue
                }
            }
        }
        err = fd.eofError(n, err)
        return n, err
    }
}

如果文件被设置为阻塞模式，则第一个n, err := ignoringEINTRIO(syscall.Read, fd.Sysfd, p)将永远阻塞。waitRead仅在文件以非阻塞模式打开时执行。但是我确实以非阻塞模式打开了文件，那么发生了什么？
os.File.Fd()broke it的实现：

func (f *File) Fd() uintptr {
    if f == nil {
        return ^(uintptr(0))
    }

    // If we put the file descriptor into nonblocking mode,
    // then set it to blocking mode before we return it,
    // because historically we have always returned a descriptor
    // opened in blocking mode. The File will continue to work,
    // but any blocking operation will tie up a thread.
    if f.nonblock {
        f.pfd.SetBlocking()
    }

    return uintptr(f.pfd.Sysfd)
}

Fd()总是将文件设置为阻塞。因此，我们必须在等待轮询读取之前撤消此操作。因此：
在使用os.File.Fd()后对文件使用syscall.SetNonblock(fd.Fd(), true)