golang-bufio 缓冲读

缓冲 IO

golang-bufio 缓冲读_第1张图片

计算机中我们常听到这样的两种程序优化方式:

  • 以时间换空间
  • 以空间换时间

今天要来看的缓冲IO就是典型的以空间换时间,它的基本原理见上图。简单的解释就是:程序不再直接去读取底层的数据源,而是通过一个缓冲区来进行读取。即先把数据从底层数据源读取到缓冲区,然后再从缓冲区进行读取。这样一分析,似乎有点多此一举了,本来一次的数据读写变成了两次?其实,不是这样的,因为这里的两个读写的成本或者说代价不同。我们都知道存储器是分级的,硬盘读写速度和内存读写速度之间的差距是巨大的:内存读写 >> 硬盘读写或者网络读写

所以缓冲区的真正作用是减少了硬盘或者网络读写的次数(读写的数据量没变)。

举一个例子:我有1024 个字节的数据,每次读取 32 个byte,那么需要访问硬盘或者网络 32次。如果一次读取 1024 个字节呢,最终只需要一次硬盘或者网络访问就够了(内存访问的次数增加,但是总的耗时是减少的)。不过,我们再扩展一点,既然内存读写这么快,我们直接把文件一次性读入内存不就好了?这样的想法是好的,但是对于大文件(GB级或者更大的),我想你是不会全部读取进内存的,因为内存资源也是有限的。

好了,前面是一些基本的概念的复习,简单回顾一下,有助于我们理解接下来的内容。今天来记录一下我阅读 golang 的 bufio 包的理解:

Package bufio implements buffered I/O. It wraps an io.Reader or io.Writer object, creating another object (Reader or Writer) that also implements the interface but provides buffering and some help for textual I/O.

这是 bufio 包自己的介绍,从它的名字来理解就是缓冲 IO

缓冲读

因为这个 bufio.go 文件还是蛮大的,所以准备分成两个缓冲读和写部分进行阅读。接下来会介绍几个我认为比较重要的方法,会有一些自己的理解。

Buffered input 缓冲输入

const (
	defaultBufSize = 4096
)

// Buffered input.

// 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 // last byte read for UnreadByte; -1 means invalid
	lastRuneSize int // size of last rune read for UnreadRune; -1 means invalid
}

const minReadBufferSize = 16
const maxConsecutiveEmptyReads = 100

这就是缓冲输入 Reader 的结构体,它有一个 buf 字节切片(默认的长度是4096,即 4KB),并且依赖 io.Reader 实现的。这里可以看出来,所谓的缓冲区其实就是一个字节切片

golang-bufio 缓冲读_第2张图片
所以如果缓冲区是空的判断条件即是:r.b == r.w

fill 填充数据

fill() 是内部用来填充缓冲区的方法,可以说能实现缓冲就是依赖它来实现的。

// fill reads a new chunk into the buffer.
func (b *Reader) fill() {
	// Slide existing data to beginning.
	if b.r > 0 {
		copy(b.buf, b.buf[b.r:b.w])
		b.w -= b.r
		b.r = 0
	}

	if b.w >= len(b.buf) {
		panic("bufio: tried to fill full buffer")
	}

	// Read new data: try a limited number of times.
	for i := maxConsecutiveEmptyReads; i > 0; i-- {
		n, err := b.rd.Read(b.buf[b.w:])
		if n < 0 {
			panic(errNegativeRead)
		}
		b.w += n
		if err != nil {
			b.err = err
			return
		}
		if n > 0 {
			return
		}
	}
	b.err = io.ErrNoProgress
}

这里是我从源码中的理解:

  1. 如果 b.r > 0,这说明缓冲区已经被读取了一些数据,所以要把后面未读取的数据搬到前面来,然后 b.w 就要减少 b.r,同时 b.r 需要置零(因为已经搬到前面了)。

  2. 如果 b.w >= len(b.buf),这种属于异常情况,会发生 panic("bufio: tried to fill full buffer")。也就是说,当你尝试向一个满的 buf 切片填充数据时,这是不允许的。这是出于程序正确性的角度考虑的。

  3. 然后就可以尝试进行填充数据了。这里很有意思,填充数据本身是在一个循环中进行的,它最多会执行 100 次([1, 100])。

循环体内的内容:

  1. 从底层的 reader 中读取数据,把读取的数据存入缓冲区的切片中,b.w 开始。

  2. 如果读取的 n < 0,那么会发生 panic。这种都是专门针对各种异常情况的处理,通常是不会发生的。

  3. 把数据写入缓冲区后,b.w 同时向后移动到数据的最后面。

  4. 如果读取数据时发生了错误,那么就返回。

如果 n > 0,那么就返回。这里很奇怪,为什么要单独 n > 0 时返回呢?因为,还有一种可能是 n == 0,如果出现这种情况,说明没有读取到数据。那么,怎么办呢?这就是前面循环的作用了,它会再次尝试读取,如果尝试 100 次都失败了,那么就停止读取,并且返回错误。(这种情况通常是因为一个错误的 reader 实现导致的)


这里举一个例子:测试字符串 CrazyDragon,假设初始缓冲区容量为10,现在开始第一次填充数据(r.b = r.w = 0),假设它读取了Crazy 这 5 个数据(这里的读取是从底层数据源读取,对于缓冲区来说它是指写入)。因为还没有开始读取(这里的读取指的是对缓冲区的读取),所以 r.b 为 0,r.w 为 5(这里你可以思考一下,为什么不是 4 呢?)。
golang-bufio 缓冲读_第3张图片
然后的操作的是:

  1. 用户读取了 3 个数据,那么现在 r.b 移动到 3 的位置,然后再次触发填充函数。
  2. 它会首先把从 r.br.w 的数据搬到(或者说复制)缓冲切片的开头.
  3. 然后从底层数据源读取 Dragon 这 6 个数据,并将其填充进缓冲区,r.w 向后移动 6。

golang-bufio 缓冲读_第4张图片
golang-bufio 缓冲读_第5张图片
golang-bufio 缓冲读_第6张图片

Peak 查看但不读取数据

注:// Tip: 以这个开头的中文注释,是我添加的理解。

// Peek returns the next n bytes without advancing the reader. The bytes stop
// being valid at the next read call. If Peek returns fewer than n bytes, it
// also returns an error explaining why the read is short. The error is
// ErrBufferFull if n is larger than b's buffer size.
//
// Calling Peek prevents a UnreadByte or UnreadRune call from succeeding
// until the next read operation.
func (b *Reader) Peek(n int) ([]byte, error) {
	if n < 0 {
		return nil, ErrNegativeCount
	}

	b.lastByte = -1
	b.lastRuneSize = -1

    // Tip:如果 n 大于缓冲区剩余的数据且缓冲区未满,会调用 fill() 将其填满
	for b.w-b.r < n && b.w-b.r < len(b.buf) && b.err == nil {
		b.fill() // b.w-b.r < len(b.buf) => buffer is not full
	}

    // Tip:如果 n 大于缓冲区的长度,会报错 ErrBufferFull
	if n > len(b.buf) {
		return b.buf[b.r:b.w], ErrBufferFull
	}

	// 0 <= n <= len(b.buf)
	var err error
    // Tip:如果最终还是剩余数据小于需要读取的数据,那么就返回剩余数据和相应的错误
	if avail := b.w - b.r; avail < n {
		// not enough data in buffer
		n = avail
		err = b.readErr()
		if err == nil {
			err = ErrBufferFull
		}
	}
    // Tip:这才是最关键的代码,只是返回缓冲区中数据的切片,其他的都错误处理相关的
	return b.buf[b.r : b.r+n], err
}

Peek 有偷看的意思,它的作用就是查看当前读取位置之后的 n 字节数据,但是不移动读取的下标。如果它返回的字节少于 n 个,它会返回一个错误来解释原因。如果 n 大于缓冲区的大小,那么会返回一个 ErrBufferFull 错误。通过调用 Peek() 可以阻止 UnreadByte 或者 UnreadRune 调用成功,直到下一次读取操作。

Discard 丢弃数据

// Discard skips the next n bytes, returning the number of bytes discarded.
//
// If Discard skips fewer than n bytes, it also returns an error.
// If 0 <= n <= b.Buffered(), Discard is guaranteed to succeed without
// reading from the underlying io.Reader.
func (b *Reader) Discard(n int) (discarded int, err error) {
	if n < 0 {
		return 0, ErrNegativeCount
	}
	if n == 0 {
		return
	}

	b.lastByte = -1
	b.lastRuneSize = -1

    // Tip:因为缓冲区里面不一定有足够的数据,所以它也是会在底层调用 fill 来填充数据的
	remain := n
	for {
		skip := b.Buffered()
		if skip == 0 {
			b.fill()
			skip = b.Buffered()
		}
		if skip > remain {
			skip = remain
		}
		b.r += skip
		remain -= skip
		if remain == 0 {
			return n, nil
		}
		if b.err != nil {
			return n - remain, b.readErr()
		}
	}
}

discard 就是丢弃的意思,这个词在 IT 领域还是很常见的,特别是和网络相关的。它的作用就是丢弃指定的 n 个字节,返回实际丢弃的字节数和相应的错误。

Read 读取数据

这个方法使用起来和正常的 IO 的 Read 是一样的,主要区别在于是先从缓冲区取数据,可能会调用一次 fill 函数填充缓存区。ReadByte 它返回下一个字节,ReadRune,它返回下一个 Unicode 字符。

UnReadByte 和 UnrReadRune 往前读

这里我把它称为往前读,因为它的作用是把读取指针向前移动。这两个方法类似,不过一个是向前移动一个字节,另一个是向前移动一个字符。

这里可以看到向前移动一个字节后,读取指针又指向了 :,本来这个字符已经被读取出来了,指针已经执行它后面的那个位置了。

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	reader := strings.NewReader("CrazyDragon: I love you yesterday and today.")
	bufReader := bufio.NewReaderSize(reader, 16)

	// 长度设置为 12,正好读取到 CrazyDragon:
	line := make([]byte, 12)
	n, err := bufReader.Read(line)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(string(line[:n]))
	// 缓冲区大小是 16,读取 12,还剩下 4
	fmt.Println("剩余缓冲数据:", bufReader.Buffered())
	// 调用 UnreadByte,读取指针前移一位,此时缓冲区还剩下 5
	bufReader.UnreadByte()
	fmt.Println(bufReader.Buffered())
	n, err = bufReader.Read(line[:1])
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(string(line[:n]))

golang-bufio 缓冲读_第7张图片

ReadSlice 读取一个切片

// ReadSlice reads until the first occurrence of delim in the input,
// returning a slice pointing at the bytes in the buffer.
// The bytes stop being valid at the next read.
// If ReadSlice encounters an error before finding a delimiter,
// it returns all the data in the buffer and the error itself (often io.EOF).
// ReadSlice fails with error ErrBufferFull if the buffer fills without a delim.
// Because the data returned from ReadSlice will be overwritten
// by the next I/O operation, most clients should use
// ReadBytes or ReadString instead.
// ReadSlice returns err != nil if and only if line does not end in delim.
func (b *Reader) ReadSlice(delim byte) (line []byte, err error) {
	s := 0 // search start index
	for {
		// Search buffer.
		if i := bytes.IndexByte(b.buf[b.r+s:b.w], delim); i >= 0 {
			i += s
			line = b.buf[b.r : b.r+i+1]
			b.r += i + 1
			break
		}

		// Pending error?
		if b.err != nil {
			line = b.buf[b.r:b.w]
			b.r = b.w
			err = b.readErr()
			break
		}

		// Buffer full?
		if b.Buffered() >= len(b.buf) {
			b.r = b.w
			line = b.buf
			err = ErrBufferFull
			break
		}

		s = b.w - b.r // do not rescan area we scanned before

		b.fill() // buffer is not full
	}

	// Handle last byte, if any.
	if i := len(line) - 1; i >= 0 {
		b.lastByte = int(line[i])
		b.lastRuneSize = -1
	}

	return
}

这个方法的作用是从缓冲区中读取数据,在第一次遇到指定的分隔符后停止,并返回一个指向缓冲区中这些字节的切片。ReadSlice 如果缓冲区填满数据但是没有一个分隔符,它会返回一个 ErrBufferFull 错误。

因为从 ReadSlice 返回的数据会被下一次的 IO 操作覆盖,所以大多数客户端应该使用 ReadBytes 或者 ReadString 来替代。

ReadSlice 只有在 line 没有结束在分隔符时,才会返回 err != nil

这里来做一个实验:测试数据为:CrazyDragon: I love you yesterday and today,因为默认的缓冲区大小是 4096 字节,这个对于测试代码太大了。但是,它也是可以设置的,最小值是 16 字节,这里我就设置成最小值来测试。

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	reader := strings.NewReader("CrazyDragon: I love you yesterday and today.")
	bufReader := bufio.NewReaderSize(reader, 16)
    // 此时还没有开始填充,如果缓冲区是空的,输出是 0
	fmt.Println("Buffered: ", bufReader.Buffered())
    // 开始从缓冲区读取,底层会调用 fill() 函数进行填充的
	line, err := bufReader.ReadSlice(':')
	if err != nil {
		fmt.Println(err)
	}
    // 这时 r.b 已经移动到相应的位置了,此时缓冲区的长度为 4
	fmt.Println("Buffered: ", bufReader.Buffered())
	fmt.Println(string(line))
    // 再次尝试读取,因为找不到分隔符,所以报错了
	_, err = bufReader.ReadSlice(':')
	if err != nil {
		fmt.Println("Error: ", err)
	}
    // 查看此时整个缓冲区的数据
    line, err = bufReader.Peek(16)
	if err != nil {
		fmt.Println("Error: ", err)
	}
	fmt.Printf("len(line) = %d, line = %s", len(line), string(line))
}

golang-bufio 缓冲读_第8张图片

所以,可见 Buffered() 输出结果是 4,r.w 为 16,r.b 为 12。不过,这种情况就是从头开始读取一个满的缓冲区,如果缓冲区本身是未满的,那么它会将缓冲区填满(不一定是一次填满,可能会多次执行 fill(),这里的情况还是很复杂的,对于网络流来说,每次你都不一定可以读取到数据),但是如果缓存区满了还是没有发现分隔符,那么就会报错。
golang-bufio 缓冲读_第9张图片

golang-bufio 缓冲读_第10张图片

ReadLine 读取一行

ReadLine 是一个低级的读取行方法。大多数调用者应该使用 ReadBytes('\n') 或者 ReadString('\n') 替代或者使用扫描器 Scanner。实际上,它在内部是这样调用的:line, err = b.ReadSlice('\n')。 不过也要注意它的不同点,它是不会返回行结束符字节的。也就是说: ReadSlice('\n') 返回的数据是包含 \n,但是 ReadLine() 是不会包含的。

如果遇到了 ErrBufferFull 错误,说明整个缓存区都没有遇到 \n。但是它还会考虑是否存在 \r\n 横跨缓冲区的情况,即 \r 是缓冲区的最后一个字节,然后 \n 还没有到来,不过这只能等待下一次调用取检查了,可以通过第二个返回值来判断是否是这种情况。

这里来测试一下:

func ReadLineTest(s string) {
	reader := strings.NewReader(s)
	bufReader := bufio.NewReaderSize(reader, 16)

	line, isPrefix, err := bufReader.ReadLine()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("line = %s, isPrefix = %v\n", string(line), isPrefix)
}

ReadLineTest("CrazyDragonKing\r\n")
ReadLineTest("CrazyDragonKing\r")
ReadLineTest("CrazyDragonKing\n")
ReadLineTest("CrazyDragonKingCrazyDragonKingCrazyDragonKing")

golang-bufio 缓冲读_第11张图片

这里来总结一下,各种可能的情况(注:缓冲区大小为 16,CrazyDragonKing 长度是 15)

"CrazyDragonKing\r\n" => "CrazyDragonKing", true, nil
"CrazyDragonKing\r"   => "CrazyDragonKing", true, nil
"CrazyDragonKing\n"   => "CrazyDragonKing", false, nil
"CrazyDragonKingCrazyDragonKingCrazyDragonKing" => CrazyDragonKingC, true, nil

ReadBytesReadString 读取字节切片和读取字符串

ReadSlice 是当遇到分隔符之后返回字节切片(包含分隔符本身),它会尝试填满缓冲区,如果没有遇到分隔符,会返回 ErrBufferFull 错误。

ReadLine 内部依赖 ReadSlice 实现,它返回的也是字节切片(不包含分隔符本身)。

ReadBytesReadString 它们两个一个返回字节切片,一个返回字符串。不同的地方在于,如果一个缓冲区没有找到,它们不会返回 ErrBufferFull 错误。而是继续读取底层的数据源,直到遇到分隔符或者文件结束。

这里来做一个实验:

func ReadStringTest(s string) {
	reader := strings.NewReader(s)
	bufReader := bufio.NewReaderSize(reader, 16)

	line, err := bufReader.ReadString('\n')
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("line = %s\n", line)
}

ReadLineTest("CrazyDragonKingCrazyDragonKingCrazyDragonKing")
ReadStringTest("CrazyDragonKingCrazyDragonKingCrazyDragonKing\nCrazyDragonKing\n")

在这里插入图片描述

collectFragments 收集片段

// collectFragments reads until the first occurrence of delim in the input. It
// returns (slice of full buffers, remaining bytes before delim, total number
// of bytes in the combined first two elements, error).
// The complete result is equal to
// `bytes.Join(append(fullBuffers, finalFragment), nil)`, which has a
// length of `totalLen`. The result is structured in this way to allow callers
// to minimize allocations and copies.
func (b *Reader) collectFragments(delim byte) (fullBuffers [][]byte, finalFragment []byte, totalLen int, err error) {
	var frag []byte
	// Use ReadSlice to look for delim, accumulating full buffers.
	for {
		var e error
		frag, e = b.ReadSlice(delim)
		if e == nil { // got final fragment
			break
		}
		if e != ErrBufferFull { // unexpected error
			err = e
			break
		}

		// Make a copy of the buffer.
		buf := bytes.Clone(frag)
		fullBuffers = append(fullBuffers, buf)
		totalLen += len(buf)
	}

	totalLen += len(frag)
	return fullBuffers, frag, totalLen, err
}

这个方法初看起来还是蛮复杂的,特别是它返回值有 4 个,不过它这样的目的是为了调用者减少内存分配和拷贝。它的内部是依赖 ReadSlice 实现的,如果直接读取到了,那么就直接返回了。否则,下面就是不同的地方了。通常,如果返回 ErrBufferFull 是说明整个缓冲区没有遇到分隔符(如果不是,说明遇到了非预期错误,直接返回),它会保存已经读取的数据,然后再调用 ReadSlice,直到遇到分隔符或者其他错误。

对比上面这行代码的执行结果:
ReadStringTest("CrazyDragonKingCrazyDragonKingCrazyDragonKing\nCrazyDragonKing\n")

总结

好了,到这里就结束了。这里至少 Reader 相关的部分,后面还会继续 Writer 相关的部分。不过,目前还没有特别好的记录方式,只是大致挑几个代码贴出来,写一些自己的理解,然后配一些示意图,再加上一些测试代码。这篇博客不是为了说明这个包是怎么使用的,而是为什么要用它,以及它的一些实现的细节。现这样写吧,以后再探索是不是有更好的方式。

你可能感兴趣的:(golang)