本篇文章为大家展示了golang中bufio包的实现原理是什么，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。

创新互联主营弋阳网站建设的网络公司,主营网站建设方案,重庆App定制开发,弋阳h5成都微信小程序搭建,弋阳网站营销推广欢迎弋阳等地区企业咨询

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)的内容，思路如下：

1. 当缓存区有内容的时，将缓存区内容全部填入p并清空缓存区

2. 当缓存区没有内容的时候且len(p)>len(buf),即要读取的内容比缓存区还要大，直接去文件读取即可

3. 当缓存区没有内容的时候且len(p)

4. 以后再次读取时缓存区有内容，将缓存区内容全部填入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) 的思路如下

1. 判断buf中可用容量是否可以放下 p

2. 如果能放下，直接把p拼接到buf后面，即把内容放到缓冲区

3. 如果缓冲区的可用容量不足以放下，且此时缓冲区是空的，直接把p写入文件即可

4. 如果缓冲区的可用容量不足以放下，且此时缓冲区有内容，则用p把缓冲区填满，把缓冲区所有内容写入文件，并清空缓冲区

5. 判断p的剩余内容大小能否放到缓冲区，如果能放下（此时和步骤1情况一样）则把内容放到缓冲区

6. 如果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大于缓存区

上述内容就是golang中bufio包的实现原理是什么，你们学到知识或技能了吗？如果还想学到更多技能或者丰富自己的知识储备，欢迎关注创新互联行业资讯频道。

网站栏目：golang中bufio包的实现原理是什么
链接分享：http://csdahua.cn/article/ghhiec.html