GOLANG：为什么 SetDeadlineSetReadDeadlineSetWriteDeadline 在使用 os.File.Fd() 时对文件不起作用

TL；DR:

在使用了os.File.Fd()之后，在文件上使用syscall.SetNonblock(fd.Fd(), true)

这是由于实施了read in 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()总是将文件设置为阻止.因此，我们必须在预期轮询读取之前undo撤消该操作.因此:

在使用了os.File.Fd()之后，在文件上使用syscall.SetNonblock(fd.Fd(), true)