源码学习 go 语言中的文件操作（下）

上篇文章分析了文件操作中的打开和读取操作。这篇文章我们来分析一下文章的写入和关闭操作。

写入文件

在讨论写文件操作前，我们首先来回忆一下读文件的操作。

File.Read(b []byte) 函数会读取 len(b) 字节的文件内容到 b。理解起来挺简单，但是这里有一个问题需要注意，那就是 2G 界限的问题。

我们在上一篇文件中说，Darwin 和 FreeBSD 一次读写数据不能大于 2GB，go 使用了 1GB 来做为每次读取的界限。

那么，当读取大于 1GB 怎么办呢？

if needsMaxRW && len(b) > maxRW {
    b = b[:maxRW]
}

Go 选择只读取 1GB 的数据，这样做问题不大。试想，我们的使用场景很多时候是这样的：

buf := make([]byte, 1024 * 1024 * 1024 * 3) // 3GB

for {
    n, _ := f.Read(buf)
    if n > 0 {
        println(buf[:n])
    }
}

为了演示方便，我省去了错误处理。当我们在 Darwin 上执行上面的命令时，虽然 b 是一个有 3GB 大小的数组，而且 f 的内容也足有 3GB，但第一次却只能读到 1GB 的数据。这不是问题，因为系统会为我们记录当前偏移，下次会从 1GB 的问题继续读取，这对我们的处理也没有问题。

假设我们有一段写文件操作的代码，与上面的读操作类似。

buf := make([]byte, 1024 * 1024 * 1024 * 3)

for {
    n, _ := Get3GData(buf)          // 获取将要写入的 3GB 数据
    if n > 0 {
        f.Write(buf)            // (1)
    }
}

代码几乎与读操作一一对应。但是这时问题来了，File.Write() 操作有 2GB（准确说是1GB）限制，也就是说这时我们有可能丢失了额外的 2GB 数据？

Go 当然不允许这样的事情发生，为了让写操作与读操作代码同样简洁，go 在实现上确保了 File.Write() 可以将 buf 的所有内容写入文件。我们来看一下 os 模块对写文件系统调用的封装。

os/file_unix.go

func (f *File) write(b []byte) (n int, err error) {
    for {
        bcap := b
        if needsMaxRW && len(bcap) > maxRW {            // (1)
            bcap = bcap[:maxRW]
        }
        m, err := fixCount(syscall.Write(f.fd, bcap))
        n += m

        if 0 < m && m < len(bcap) || err == syscall.EINTR {
            b = b[m:]
            continue
        }

        if needsMaxRW && len(bcap) != len(b) && err == nil {    // (2)
            b = b[m:]
            continue
        }

        return n, err
    }
}

代码 (1) 处，如果当前系统存在 2GB 限制，将 bcap 限制到 1GB。代码 (2) 处，如果当前系统存在 2GB 限制，并且 len(b) 大于 1GB，让 b 偏移过已经成功读取的文件，并继续 for 循环。

File.Write() 的代码增加了对异常情况的包装处理，我们来看一下它的实现。

os/file.go

func (f *File) Write(b []byte) (n int, err error) {
    if f == nil {               // 无效文件
        return 0, ErrInvalid
    }
    n, e := f.write(b)
    if n < 0 {              // 负值字节数处理
        n = 0
    }
    if n != len(b) {            // 错误字节数
        err = io.ErrShortWrite
    }

    epipecheck(f, e)            // pipe broken 处理，可以暂时忽略

    if e != nil {               // write() 错误处理
        err = &PathError{"write", f.name, e}
    }
    return n, err
}

类似 File.ReadAt()，go 也实现了一个 File.WriteAt() 方法。

os/file.go

func (f *File) WriteAt(b []byte, off int64) (n int, err error) {
    if f == nil {
        return 0, ErrInvalid
    }
    for len(b) > 0 {
        m, e := f.pwrite(b, off)
        if e != nil {
            err = &PathError{"write", f.name, e}
            break
        }
        n += m
        b = b[m:]
        off += int64(m)
    }
    return
}

其中，f.pwrite() 只是对系统调用 pwrite() 的简单封装。

如果你还记得我们的 File.ReadAt() 函数，你或许会发现它们惊人的相似。再如果你跟我一样无聊，或许也会把两个函数拿来对比一下。结果见下图。

Screen Shot 2017-09-15 at 10.14.49 PM.png

关闭文件

func (f *File) Close() error {
    if f == nil {
        return ErrInvalid
    }
    return f.file.close()
}

func (file *file) close() error {
    if file == nil || file.fd < 0 {
        return syscall.EINVAL
    }
    var err error
    if e := syscall.Close(file.fd); e != nil {
        err = &PathError{"close", file.name, e}
    }
    file.fd = -1 // so it can't be closed again

    // no need for a finalizer anymore
    runtime.SetFinalizer(file, nil)
    return err
}

关闭函数主要是对系统调用 close() 的简单封装。

在关闭文件后，系统调用了 runtime.SetFinalizer() 将 finalizer 清除。在上一篇中，我们看到在实例化 File 的 NewFile() 函数中，系统调用 runtime.SetFinalizer() 将 close() 函数设置为 File 的 finalizer。此时文件关闭，此 finalizer 已不再需要。

pread()、pwrite() 的特殊性

这是两个系统调用，之于 read() 和 write() 特殊之处在于，它们不会修改文件偏移。不过这个细节已经被 File.ReadAt(b []byte) 和 File.WriteAt(b []byte) 封装了，这两个函数会填充或写入所有的 b。

归纳总结

现在是时候列举一下我们这两天学过的接口了。

func OpenFile(name string, flag int, perm FileMode) (*File, error)
func Open(name string) (*File, error)
func Create(name string) (*File, error)

func (f *File) Read(b []byte) (n int, err error)
func (f *File) ReadAt(b []byte, off int64) (n int, err error)

func (f *File) Write(b []byte) (n int, err error)
func (f *File) WriteAt(b []byte, off int64) (n int, err error)

func (f *File) Close() error

接下来？

这两篇文件讲到了文件读写操作，这是我们经常用到的功能。当然，还不全，因为还有设置读写偏移等其它的函数。

这些函数只是对系统调用的简单封装，如果需要，读者可以自行阅读。

如果你发现 os.Open() 和 os.Create() 不能满足你的需求，比如你想要的类似文件的 O_APPEND 选项，大胆的使用 OpenFile() 吧。