详解golang中bufio包的实现原理
最近用golang写了一个处理文件的脚本,由于其中涉及到了文件读写,开始使用golang中的 io 包,后来发现golang 中提供了一个bufio的包,使用这个包可以大幅提高文件读写的效率,于是在网上搜索同样的文件读写为什么bufio 要比io的读写更快速呢?根据网上的资料和阅读源码,以下来详细解释下bufio的高效如何实现的。
bufio 包介绍
bufio包实现了有缓冲的i/o。它包装一个io.reader或io.writer接口对象,创建另一个也实现了该接口,且同时还提供了缓冲和一些文本i/o的帮助函数的对象。
以上为官方包的介绍,在其中我们能了解到的信息如下:
bufio 是通过缓冲来提高效率
简单的说就是,把文件读取进缓冲(内存)之后再读取的时候就可以避免文件系统的io 从而提高速度。同理,在进行写操作时,先把文件写入缓冲(内存),然后由缓冲写入文件系统。看完以上解释有人可能会表示困惑了,直接把 内容->文件 和 内容->缓冲->文件相比, 缓冲区好像没有起到作用嘛。其实缓冲区的设计是为了存储多次的写入,最后一口气把缓冲区内容写入文件。下面会详细解释
bufio 封装了io.reader或io.writer接口对象,并创建另一个也实现了该接口的对象
io.reader或io.writer 接口实现read() 和 write() 方法,对于实现这个接口的对象都是可以使用这两个方法的
bufio 包实现原理
bufio 源码分析
reader对象
bufio.reader 是bufio中对io.reader 的封装
// reader implements buffering for an io.reader object. type reader struct { buf []byte rd io.reader // reader provided by the client r, w int // buf read and write positions err error lastbyte int lastrunesize int }
bufio.read(p []byte) 相当于读取大小len(p)的内容,思路如下:
- 当缓存区有内容的时,将缓存区内容全部填入p并清空缓存区
- 当缓存区没有内容的时候且len(p)>len(buf),即要读取的内容比缓存区还要大,直接去文件读取即可
- 当缓存区没有内容的时候且len(p)<len(buf),即要读取的内容比缓存区小,缓存区从文件读取内容充满缓存区,并将p填满(此时缓存区有剩余内容)
- 以后再次读取时缓存区有内容,将缓存区内容全部填入p并清空缓存区(此时和情况1一样)
以下是源码
// read reads data into p. // it returns the number of bytes read into p. // the bytes are taken from at most one read on the underlying reader, // hence n may be less than len(p). // at eof, the count will be zero and err will be io.eof. func (b *reader) read(p []byte) (n int, err error) { n = len(p) if n == 0 { return 0, b.readerr() } if b.r == b.w { if b.err != nil { return 0, b.readerr() } if len(p) >= len(b.buf) { // large read, empty buffer. // read directly into p to avoid copy. n, b.err = b.rd.read(p) if n < 0 { panic(errnegativeread) } if n > 0 { b.lastbyte = int(p[n-1]) b.lastrunesize = -1 } return n, b.readerr() } // one read. // do not use b.fill, which will loop. b.r = 0 b.w = 0 n, b.err = b.rd.read(b.buf) if n < 0 { panic(errnegativeread) } if n == 0 { return 0, b.readerr() } b.w += n } // copy as much as we can n = copy(p, b.buf[b.r:b.w]) b.r += n b.lastbyte = int(b.buf[b.r-1]) b.lastrunesize = -1 return n, nil }
说明:
reader内部通过维护一个r, w 即读入和写入的位置索引来判断是否缓存区内容被全部读出
writer对象
bufio.writer 是bufio中对io.writer 的封装
// writer implements buffering for an io.writer object. type writer struct { err error buf []byte n int wr io.writer }
bufio.write(p []byte) 的思路如下
- 判断buf中可用容量是否可以放下 p
- 如果能放下,直接把p拼接到buf后面,即把内容放到缓冲区
- 如果缓冲区的可用容量不足以放下,且此时缓冲区是空的,直接把p写入文件即可
- 如果缓冲区的可用容量不足以放下,且此时缓冲区有内容,则用p把缓冲区填满,把缓冲区所有内容写入文件,并清空缓冲区
- 判断p的剩余内容大小能否放到缓冲区,如果能放下(此时和步骤1情况一样)则把内容放到缓冲区
- 如果p的剩余内容依旧大于缓冲区,(注意此时缓冲区是空的,情况和步骤2一样)则把p的剩余内容直接写入文件
以下是源码
// write writes the contents of p into the buffer. // it returns the number of bytes written. // if nn < len(p), it also returns an error explaining // why the write is short. func (b *writer) write(p []byte) (nn int, err error) { for len(p) > b.available() && b.err == nil { var n int if b.buffered() == 0 { // large write, empty buffer. // write directly from p to avoid copy. n, b.err = b.wr.write(p) } else { n = copy(b.buf[b.n:], p) b.n += n b.flush() } nn += n p = p[n:] } if b.err != nil { return nn, b.err } n := copy(b.buf[b.n:], p) b.n += n nn += n return nn, nil }
说明:
b.wr 存储的是一个io.writer对象,实现了write()的接口,所以可以使用b.wr.write(p) 将p的内容写入文件
b.flush() 会将缓存区内容写入文件,当所有写入完成后,因为缓存区会存储内容,所以需要手动flush()到文件
b.available() 为buf可用容量,等于len(buf) - n
下图解释的是其中一种情况,即缓存区有内容,剩余p大于缓存区
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。
上一篇: beego获取ajax数据的实例
下一篇: Lua脚本语言入门笔记