Golang - 使用 bufio 提升高频写文件操作的效率

目录

• 背景
• 具体示例
• 未使用`bufio`的写操作
• 使用`bufio`之后的写操作
• 效率对比
• 注意
• 1. 关闭文件之前先进行 `flush` 操作
• 2. 注意seek操作
• 异常的例子
• 正常的例子
• 结论
• 番外

背景

最近在写一个通过ftp客户端lib下载ftp-server文件的功能，以前是直接用 wget 命令下载的，然后用ftp客户端下载的时候就发现，速度慢了很多，如果server没有变动，那肯定是client出问题了，于是研究了一下下载的逻辑，其中有一个循环从conn read data的操作，最后定位是高频写操作过慢导致的问题，于是自己测试并修改之后，性能确实恢复了！

具体示例

未使用bufio的写操作

package main

import (
	"fmt"
	"log"
	"os"
	"strconv"
	"testing"
	"time"
)

func Test_FileWrite(t *testing.T) {
	dstFile, err := os.OpenFile("/tmp/test.txt", os.O_CREATE|os.O_WRONLY, os.ModePerm)
	if err != nil {
		log.Fatalf("open file failed, err:%v", err)
	}
	st := time.Now()
	defer func() {
		dstFile.Close()
		fmt.Println("文件写入耗时：", time.Now().Sub(st).Seconds(), "s")
	}()

	for i := 0; i < 100000; i++ {
		dstFile.WriteString(strconv.Itoa(i) + "\n")
	}
}

执行结果：

=== RUN   Test_FileWrite
文件写入耗时： 0.626794301 s
--- PASS: Test_FileWrite (0.63s)
PASS

使用bufio之后的写操作

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strconv"
	"testing"
	"time"
)

func Test_FileWrite(t *testing.T) {
	dstFile, err := os.OpenFile("/tmp/test.txt", os.O_CREATE|os.O_WRONLY, os.ModePerm)
	if err != nil {
		log.Fatalf("open file failed, err:%v", err)
	}
	bufWriter := bufio.NewWriter(dstFile)
	st := time.Now()
	defer func() {
		bufWriter.Flush()
		dstFile.Close()
		fmt.Println("文件写入耗时：", time.Now().Sub(st).Seconds(), "s")
	}()

	for i := 0; i < 100000; i++ {
		bufWriter.WriteString(strconv.Itoa(i) + "\n")
	}
}

执行结果：

=== RUN   Test_FileWrite
文件写入耗时： 0.022134496 s
--- PASS: Test_FileWrite (0.02s)
PASS

效率对比

0.62s vs 0.02s 优化还是很明显的

注意

1. 关闭文件之前先进行 flush 操作

bufio 通过 flush 操作将缓冲写入真实的文件的，所以一定要在关闭文件之前先flush，否则会造成数据丢失的情况。下面是一个忘记flush的实例：

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strconv"
	"testing"
	"time"
)

func Test_FileWrite(t *testing.T) {
	dstFile, err := os.OpenFile("/tmp/test.txt", os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
	if err != nil {
		log.Fatalf("open file failed, err:%v", err)
	}
	bufWriter := bufio.NewWriter(dstFile)
	st := time.Now()
	defer func() {
		//bufWriter.Flush()   //不进行flush会丢失数据
		dstFile.Close()
		fmt.Println("文件写入耗时：", time.Now().Sub(st).Seconds(), "s")
	}()

	for i := 0; i < 100000; i++ {
		bufWriter.WriteString(strconv.Itoa(i) + "\n")
	}
}

查看写入行数，明显缺少了！

➜  tmp wc -l /tmp/test.txt
   99473 /tmp/test.txt

2. 注意seek操作

想要移动文件指针调用 Seek() 函数需要特别注意，因为这个时候，文件的写入是带缓冲的，一定要避免seek操作的同时，缓冲区和文件没有同步的情况。

异常的例子

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strconv"
	"testing"
	"time"
)

func Test_FileWrite(t *testing.T) {
	dstFile, err := os.OpenFile("/tmp/test.txt", os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
	if err != nil {
		log.Fatalf("open file failed, err:%v", err)
	}
	bufWriter := bufio.NewWriter(dstFile)
	st := time.Now()
	defer func() {
		bufWriter.Flush()
		dstFile.Close()
		fmt.Println("文件写入耗时：", time.Now().Sub(st).Seconds(), "s")
	}()

	for i := 0; i < 100000; i++ {
		dstFile.Seek(0, os.SEEK_SET)
		bufWriter.WriteString(strconv.Itoa(i) + "\n")
	}
}

先说下我们的预期，实际上是每次写一行，然后再移动到第一行，最后覆盖掉第一行，依次往复，文件中应该只有一行，但是因为缓冲的存在，实际上每次写入了一大块，就会造成不符合预期的情况：

➜  tmp wc -l /tmp/test.txt
     683 /tmp/test.txt

正常的例子

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strconv"
	"testing"
	"time"
)

func Test_FileWrite(t *testing.T) {
	dstFile, err := os.OpenFile("/tmp/test.txt", os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
	if err != nil {
		log.Fatalf("open file failed, err:%v", err)
	}
	bufWriter := bufio.NewWriter(dstFile)
	st := time.Now()
	defer func() {
		bufWriter.Flush()
		dstFile.Close()
		fmt.Println("文件写入耗时：", time.Now().Sub(st).Seconds(), "s")
	}()

	for i := 0; i < 100000; i++ {
		dstFile.Seek(0, os.SEEK_SET)
		dstFile.WriteString(strconv.Itoa(i) + "\n")

		//直接使用文件指针进行文件写操作，或者使用 bufio + 每次写操作之后flush 也能达到相同的目的(不过就没有bufio的效果了)
		//bufWriter.WriteString(strconv.Itoa(i) + "\n")
		//bufWriter.Flush()
	}
}

正常的结果，写入只有一行

➜  tmp wc -l /tmp/test.txt
       1 /tmp/test.txt

结论

bufio 在一定场景下还是很能提升效率的，不过还是需要注意与直接写入文件的异同，防止数据未同步的状况发生。

番外

除了bufio 之外，实际上操作系统也自带buf，这个是内存和磁盘之间的buf，不同进程对同一个文件的不同位置进行操作时，就有可能因为还没有写入磁盘，导致读取异常，如果想实时同步，也有对应的方法：

// Sync commits the current contents of the file to stable storage.
// Typically, this means flushing the file system's in-memory copy
// of recently written data to disk.
func (f *File) Sync() error {
	if err := f.checkValid("sync"); err != nil {
		return err
	}
	if e := f.pfd.Fsync(); e != nil {
		return f.wrapErr("sync", e)
	}
	return nil
}

hello world~