Golang bufio包源码分析

go 源码1.10.3   bufio.go

 

一、bufio介绍

bufio实现了带缓冲的IO功能，它是在io.Reader和io.Writer接口对象上提供了进一步的封装，从而提供了更加丰富的操作方法。bufio包主要

 

二、bufio.Reader

1.结构体

type Reader struct {
	buf          []byte    //缓冲区的数据
	rd           io.Reader // 底层的io.Reader
	r, w         int       //  r ,w分别表示 buf中读和写的指针位置
	err          error    //记录本次读取的error，后续操作中调用readErr函数后会重置err
	lastByte     int      //记录读取的最后一个字节（用于撤销）
	lastRuneSize int      //记录读取的最后一个字符(Rune)的长度（用于撤销）
}

bufio.Reader封装了io.Reader对象，并提供了带缓冲的功能。

 

2. 初始化方法

func NewReaderSize(rd io.Reader, size int) *Reader {
	// Is it already a Reader?
	b, ok := rd.(*Reader)
	if ok && len(b.buf) >= size {
		return b
	}
	if size < minReadBufferSize {
		size = minReadBufferSize
	}
	r := new(Reader)
	r.reset(make([]byte, size), rd)
	return r
}

         size用于指定缓冲区的大小，如果size小于minReadBufferSize，则重置size的值为minReadBufferSize（16）。如果该rd是*bufio.Reader对象，并且rd的缓冲区大于size，则不会创建Reader对象，而是直接返回原来的rd对象。否则会创建一个*bufio.Reader对象，并指定buf的大小为size。

 

    

const (
	defaultBufSize = 4096
)


func NewReader(rd io.Reader) *Reader {
	return NewReaderSize(rd, defaultBufSize)
}

创建缓冲区默认大小为defaultBufSize(4096)的*bufio.Reader对象

 

3.Reader常用方法

   

func (b *Reader) Size() int { return len(r.buf) }

  Size方法返回底层缓冲区的大小

 

func (b *Reader) Reset(r io.Reader) {
	b.reset(b.buf, r)
}

func (b *Reader) reset(buf []byte, r io.Reader) {
	*b = Reader{
		buf:          buf,
		rd:           r,
		lastByte:     -1,
		lastRuneSize: -1,
	}
}

   Reset方法丢弃所有缓冲数据，重置所有状态，并切换reader到r，从而从r中读取数据。

 

func (b *Reader) fill() {
	// Slide existing data to beginning.
	if b.r > 0 {
		/*
		将buf中未读的数据copy到buf中首部位置
		重置r和w 位置
		*/
		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.
	/*
	maxConsecutiveEmptyReads是最多尝试次数
	从rd Reader中读取数据到缓冲区buf中，并重置w的位置索引
	*/
	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
}

     fill方法用于将缓冲区读满，可以读入的最大长度是：len(buf)-未读的字节数，如果尝试读取了maxConsecutiveEmptyReads(100)次都没有读取到数据，则会返回。

  

func (b *Reader) Peek(n int) ([]byte, error) {
	if n < 0 {
		return nil, ErrNegativeCount
	}

	/*
	如果buf中未读的字节数小于n
	并且buf中未读的字节数小于buf的总大小
	并且err为nil
	满足以上3个条件，则调用fill方法尝试从Reader中读取部分数据块
	*/
	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
	}

	/*
	如果n大于buf的长度，则返回所有未读的内容，和ErrBufferFull的错误信息
	*/
	if n > len(b.buf) {
		return b.buf[b.r:b.w], ErrBufferFull
	}

	// 0 <= n <= len(b.buf)
	var err error
	/*
	如果n大于可读的长度，则返回error信息
	*/
	if avail := b.w - b.r; avail < n {
		// not enough data in buffer
		n = avail
		err = b.readErr()
		if err == nil {
			err = ErrBufferFull
		}
	}
	return b.buf[b.r : b.r+n], err
}

       Peek返回输入流的前n个字节，而不会移动读取位置。该操作不会将数据读出，只是引用，引用的数据在下一次读取操作之前是有效的，如果Peek返回的切片长度比n小，它也会返会一个错误说明原因。如果n比缓冲尺寸还大，返回的错误将是ErrBufferFull。

 

func (b *Reader) Discard(n int) (discarded int, err error) {
	if n < 0 {
		return 0, ErrNegativeCount
	}
	if n == 0 {
		return
	}
	remain := n  //remain记录剩余要跳过的字节长度
	for {
		skip := b.Buffered() //获取buf中可读的数据长度
		if skip == 0 {//如果可读的数据长度为0，则尝试从底层rd  Reader中读取数据到buf中，然后再获取buf中可读的数据长度
			b.fill()
			skip = b.Buffered()
		}
		if skip > remain {//设置skip
			skip = remain
		}
		b.r += skip  //设置r的位置，改变读的索引值r
		remain -= skip
		if remain == 0 { //如果已经跳过n个字节，则返回
			return n, nil
		}
		if b.err != nil {
			return n - remain, b.readErr()
		}
	}
}

       Discard 方法跳过后续的 n 个字节的数据，返回跳过的字节数。如果结果小于 n，将返回错误信息。如果 n 小于缓存中的数据长度，则不会从底层提取数据。

 

func (b *Reader) Read(p []byte) (n int, err error) {
	n = len(p)
	if n == 0 {  //如果p的长度为0，则直接返回
		return 0, b.readErr()
	}
	if b.r == b.w {  //缓冲区没有可读的数据
		if b.err != nil { //如果上次读取有error，则直接返回
			return 0, b.readErr()
		}
		if len(p) >= len(b.buf) { //如果 len(p) >=  缓冲区大小
			// Large read, empty buffer.
			// Read directly into p to avoid copy.
			n, b.err = b.rd.Read(p)  //直接读取rd中的数据到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.
		/*
		如果len(p) < 缓冲区大小，将读(r)的位置和写(w)的位置设为0，并从rd中读取数据到缓冲区buf中
		*/
		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])  //将数据copy到p中
	b.r += n  //并更新读的位置
	b.lastByte = int(b.buf[b.r-1])  //记录读取的最后一个字节
	b.lastRuneSize = -1
	return n, nil
}

        Read从Reader对象b中读出数据到p中，n是返回读取的字节数。如果Reader对象b中的缓冲区buf不为空，则只能读取缓冲中的数据，不会从底层的io.Reader中读取数据。

如果b中的缓冲buf为空，则：

1. len(p) >= 缓冲大小，则跳过缓存，直接从底层io.Reader中读出到p总

2.len(p)<缓存大小，则先将数据从底层的io.Reader中读取到缓存中，再从缓存buf读取到p中。

 

func (b *Reader) ReadByte() (byte, error) {
	b.lastRuneSize = -1
	for b.r == b.w {
		if b.err != nil {
			return 0, b.readErr()
		}
		b.fill() // buffer is empty
	}
	c := b.buf[b.r]
	b.r++
	b.lastByte = int(c) //记录读取的最后一个字节
	return c, nil
}

ReadByte 方法读取并返回一个字节的数据，如果没有可读的字节，则返回一个error

 

// UnreadByte unreads the last byte. Only the most recently read byte can be unread.
func (b *Reader) UnreadByte() error {
	if b.lastByte < 0 || b.r == 0 && b.w > 0 {  //条件判断
		return ErrInvalidUnreadByte
	}
	// b.r > 0 || b.w == 0
	if b.r > 0 { //b.r大于0，则减小读的索引
		b.r--
	} else { //如果b.r为0，则将写w的索引设为1
		// b.r == 0 && b.w == 0
		b.w = 1
	}
	b.buf[b.r] = byte(b.lastByte)  //缓冲区buf中添加最后读的一个字节
	b.lastByte = -1  //将lastByte置为-1
	b.lastRuneSize = -1
	return nil
}

       UnreadByte方法撤销最近一次读取操作读取 最后一个字节(只能撤销最后一个字节，多次调用会有问题)。

 

func (b *Reader) ReadRune() (r rune, size int, err error) {

	/*
	当满足：
	1.可读的字节数小于UTFMax（UTFMax是一个UTF字符占用的最大字节数）
	2.可读的数据不够填充一个UTF-8字符
	3.没有error
	4.可读的字节数小于len(b.buf)
	当满足以上几个条件会调用fill来从io.Reader中读出内容到buf中
	*/
	for b.r+utf8.UTFMax > b.w && !utf8.FullRune(b.buf[b.r:b.w]) && b.err == nil && b.w-b.r < len(b.buf) {
		b.fill() // b.w-b.r < len(buf) => buffer is not full
	}
	b.lastRuneSize = -1  //重置lastRuneSize
	if b.r == b.w {  //当没有可读数据
		return 0, 0, b.readErr()
	}
	r, size = rune(b.buf[b.r]), 1
	if r >= utf8.RuneSelf { //不是ascii码
		r, size = utf8.DecodeRune(b.buf[b.r:b.w]) //读取一个字符r和长度size
	}
	b.r += size
	b.lastByte = int(b.buf[b.r-1])  //设置lastByte
	b.lastRuneSize = size  //设置lastRuneSize
	return r, size, nil
}

    ReadRune  读取一个UTF-8字符，并且返回该字符r，该字符的所占的字节数size，以及可能出现的error，如果UTF-8编码的字符无效，则消耗一个字节并返回大小为1的unicode.ReplacementChar（U + FFFD）

 

func (b *Reader) UnreadRune() error {
	if b.lastRuneSize < 0 || b.r < b.lastRuneSize {
		return ErrInvalidUnreadRune
	}
	b.r -= b.lastRuneSize //修改读的索引r
	b.lastByte = -1
	b.lastRuneSize = -1
	return nil
}

      UnreadRune方法撤销上一次读取UTF-8字符的操作

 

func (b *Reader) Buffered() int { return b.w - b.r }

  Buffered方法返回buf中可读的数据长度

 

func (b *Reader) ReadSlice(delim byte) (line []byte, err error) {
	for {
		// Search buffer.
		//从buf中未读的数据中查找delim字节
		//如果可以找到则返回buf中的切片，并设置读的索引位置r，并跳出循环
		if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 {
			line = b.buf[b.r : b.r+i+1]
			b.r += i + 1
			break
		}

		// Pending error?
		if b.err != nil {  //如果上次读操作出现error，则返回
			line = b.buf[b.r:b.w]
			b.r = b.w
			err = b.readErr()
			break
		}

		// Buffer full?
		if b.Buffered() >= len(b.buf) { //如果buf是满的，则返回整个buf，并设置错误ErrBufferFull
			b.r = b.w
			line = b.buf
			err = ErrBufferFull
			break
		}

		b.fill() // buffer is not full 如果buf没有满，则向buf中读入数据
	}

	// Handle last byte, if any.
	if i := len(line) - 1; i >= 0 {
		b.lastByte = int(line[i])  //设置最后一个字节
		b.lastRuneSize = -1
	}

	return
}

 ReadSlice方法在b中查找delim字节并返回delim及之前的所有数据，返回的是buf的切片

如果找到delim，则返回查找结果，err为nil

如果未找到delim，则：

1.缓存不满，则将缓存填满后再次查找

2.缓存是满的，则返回整个缓存，err返回ErrBufferFull

3.如果未找到delim且遇到错误(通常是io.EOF)，则返回缓存中的所有数据和遇到的错误。

因为返回的数据有可能被下一次的读写操作修改，所以大多数操作应该使用ReadBytes或ReadString，它们返回的数据的拷贝

 

func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error) {
	//通过ReadSlice读取一行内容，返回的是buf的切片，在下次的读写操作时内容可能会改变
	line, err = b.ReadSlice('\n')
	if err == ErrBufferFull {
		// Handle the case where "\r\n" straddles the buffer.
		if len(line) > 0 && line[len(line)-1] == '\r' {
			// Put the '\r' back on buf and drop it from line.
			// Let the next call to ReadLine check for "\r\n".
			if b.r == 0 {
				// should be unreachable
				panic("bufio: tried to rewind past start of buffer")
			}
			b.r--
			line = line[:len(line)-1]
		}
		return line, true, nil
	}

	if len(line) == 0 {
		if err != nil {
			line = nil
		}
		return
	}
	err = nil

	if line[len(line)-1] == '\n' {
		drop := 1
		if len(line) > 1 && line[len(line)-2] == '\r' {
			drop = 2
		}
		line = line[:len(line)-drop]
	}
	return
}

ReadLine方法是一个低水平的行读取操作，大多数情况下，应该使用

ReadBytes('\n')或ReadString('\n')，或者使用Scanner

ReadLine 通过调用 ReadSlice 方法实现，返回的也是缓存的切片。用于读取一行数据，不包括行尾标记（\n 或 \r\n）。

 

func (b *Reader) ReadBytes(delim byte) ([]byte, error) {
	// Use ReadSlice to look for array,
	// accumulating full buffers.
	var frag []byte
	var full [][]byte  //可能多次从底层io.Reader中读取数据
	var err error
	for {//可能多次调用ReadSlice去查找delim字节，直到找到或unexpected error(包括io.EOF)
		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 := make([]byte, len(frag))
		copy(buf, frag)
		full = append(full, buf)
	}

	// Allocate new buffer to hold the full pieces and the fragment.
	n := 0
	for i := range full {
		n += len(full[i])
	}
	n += len(frag)

	// Copy full pieces and fragment in.
	buf := make([]byte, n)
	n = 0
	for i := range full {
		n += copy(buf[n:], full[i])
	}
	copy(buf[n:], frag)
	return buf, err
}

ReadBytes 方法从b中读取数据 直到第一次出现delim字节

功能类似ReadSlice，

不同点：

1.只不过返回的是缓存buf的copy，这样当下次读写操作也不会影响返回的内容

2.ReadSlice最多在整个len(buf)中查找，如果未找到返回ErrBufferFull。但是ReadBytes还会继续从io.Reader中读取数据，直到找到该delim字节，或者io.EOF，或者出现unexpected error

也就是ReadSlice最多返回的切片长度为len(buf),而ReadBytes返回的切片长度可能会大于len(buf)

 

func (b *Reader) ReadString(delim byte) (string, error) {
	bytes, err := b.ReadBytes(delim)
	return string(bytes), err
}

ReadString方法功能同ReadBytes，只不过把ReadBytes返回的切片转成字符串

 

func (b *Reader) WriteTo(w io.Writer) (n int64, err error) {
	n, err = b.writeBuf(w)
	if err != nil {
		return
	}

	if r, ok := b.rd.(io.WriterTo); ok {
		m, err := r.WriteTo(w)
		n += m
		return n, err
	}

	if w, ok := w.(io.ReaderFrom); ok {
		m, err := w.ReadFrom(b.rd)
		n += m
		return n, err
	}

	if b.w-b.r < len(b.buf) {
		b.fill() // buffer not full
	}

	for b.r < b.w {
		// b.r < b.w => buffer is not empty
		m, err := b.writeBuf(w)
		n += m
		if err != nil {
			return n, err
		}
		b.fill() // buffer is empty
	}

	if b.err == io.EOF {
		b.err = nil
	}

	return n, b.readErr()
}

WriteTo 实现了 io.WriterTo，可能会多次调用底层Reader的Read方法。

功能：向w中写入数据，  直到底层的io.Reader(即rd)没有可读的数据

 

// writeBuf writes the Reader's buffer to the writer.
func (b *Reader) writeBuf(w io.Writer) (int64, error) {
	n, err := w.Write(b.buf[b.r:b.w])
	if n < 0 {
		panic(errNegativeWrite)
	}
	b.r += n
	return int64(n), err
}

writeBuf方法用于将Reader中buffer中可读的数据写入到该writer中

 

三、bufio.Writer

1.结构体

type Writer struct {
	err error  //
	buf []byte  //缓冲区
	n   int  //下次写入缓冲区的索引
	wr  io.Writer  //底层的io.Writer
}

  bufio.Writer结构退封装了io.Writer，实现带缓冲的功能。

 

2.初始化

func NewWriterSize(w io.Writer, size int) *Writer {
	// Is it already a Writer?
	b, ok := w.(*Writer)
	if ok && len(b.buf) >= size {
		return b
	}
	if size <= 0 {
		size = defaultBufSize
	}
	return &Writer{
		buf: make([]byte, size),
		wr:  w,
	}
}

返回一个新的bufio.Writer的对象，size为缓冲区buf的至少长度

1.当w为bufio.Writer，并且其buf的大小大于size，则直接返回该对象

2.如果size小于等于0，则defaultBufSize

3.创建新的Writer并返回

 

func NewWriter(w io.Writer) *Writer {
	return NewWriterSize(w, defaultBufSize)
}

创建默认缓冲大小的Writer对象，默认缓冲区为defaultBufSize (4096)

 

3.Writer常用方法

func (b *Writer) Size() int { return len(b.buf) }

Size方法返回该Writer的buf大小

 

// Reset discards any unflushed buffered data, clears any error, and
// resets b to write its output to w. 
func (b *Writer) Reset(w io.Writer) {
	b.err = nil
	b.n = 0
	b.wr = w
}

Reset方法用于重置Writer中的io.Writer

 

// Flush writes any buffered data to the underlying io.Writer.
func (b *Writer) Flush() error {
	if b.err != nil {
		return b.err
	}
	if b.n == 0 {
		return nil
	}
	n, err := b.wr.Write(b.buf[0:b.n])  //将缓冲区的数据写入到底层io.Writer中
	if n < b.n && err == nil {
		err = io.ErrShortWrite
	}
	if err != nil {
		if n > 0 && n < b.n {
			copy(b.buf[0:b.n-n], b.buf[n:b.n])
		}
		b.n -= n
		b.err = err
		return err
	}
	b.n = 0  //重置n
	return nil
}

Flush将缓冲区buf中的数据写入到底层的io.Writer

 

// Available returns how many bytes are unused in the buffer. 
func (b *Writer) Available() int { return len(b.buf) - b.n }

Available方法获取缓冲区buf中可用的字节数

 

// Buffered returns the number of bytes that have been written into the current buffer.
func (b *Writer) Buffered() int { return b.n }

Buffered方法返回缓冲区buf写入的字节数

 

func (b *Writer) Write(p []byte) (nn int, err error) {
	for len(p) > b.Available() && b.err == nil {//如果len(p)的长度大于缓冲区可用的字节数
		var n int
		if b.Buffered() == 0 { //buf中没有写入的数据，说明len(p) > buf的长度，则将p直接写入到底层的io.Writer
			// Large write, empty buffer.
			// Write directly from p to avoid copy.
			n, b.err = b.wr.Write(p)
		} else {
			/*
			如果buf中已经有写入的数据，则将p中的内容追加到缓冲区的尾部。
			可能p中的数据会全部写入到缓冲区中，也能能p中的数据未全部写入到缓冲区中
			*/
			n = copy(b.buf[b.n:], p)
			b.n += 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
}

Write将p的内容写入到缓冲区中，返回写入的长度

如果nn < len(p)，将返回一个error来解释原因

需要保证写入的顺序，如果缓冲区buf中已经有写入的数据，则将p中的数据先写到缓冲区中

 

// WriteByte writes a single byte. 
func (b *Writer) WriteByte(c byte) error {
	if b.err != nil {
		return b.err
	}
	if b.Available() <= 0 && b.Flush() != nil { //如果缓冲区中没有可用的字节数，则调用Flush刷新缓存区，如果出现error，则返回该error
		return b.err
	}
	b.buf[b.n] = c  //将该字节追加到缓冲区中
	b.n++  //更新缓存区写的索引
	return nil
}

WriteByte方法用向Writer中写入一个字节

 

func (b *Writer) WriteRune(r rune) (size int, err error) {
	if r < utf8.RuneSelf { //r是一个字节，则调用WriteByte
		err = b.WriteByte(byte(r))
		if err != nil {
			return 0, err
		}
		return 1, nil
	}
	if b.err != nil {
		return 0, b.err
	}
	n := b.Available()
	if n < utf8.UTFMax {  //如果缓冲区中可用的字节小于UTFMax(字符最多占用4个字节)
		if b.Flush(); b.err != nil {  //刷新缓冲区
			return 0, b.err
		}
		n = b.Available()
		if n < utf8.UTFMax {
			// Can only happen if buffer is silly small.
			return b.WriteString(string(r)) //如果缓冲区的长度小于4，则调用WriteString写入到底层的io.Writer中
		}
	}
	size = utf8.EncodeRune(b.buf[b.n:], r)//将该字符写入到缓冲区中，并返回大小
	b.n += size
	return size, nil
}

WriteRune方法用于向Writer中写入一个字符

 

func (b *Writer) WriteString(s string) (int, error) {
	nn := 0
	for len(s) > b.Available() && b.err == nil {  //如果字符串s大于缓冲区中可用的字节数，则先把缓冲区写满，然后调用Flush刷新
		n := copy(b.buf[b.n:], s)
		b.n += n
		nn += n
		s = s[n:]
		b.Flush()
	}
	if b.err != nil {
		return nn, b.err
	}
	n := copy(b.buf[b.n:], s)  //将s中剩余的写入到缓冲区buf中
	b.n += n
	nn += n
	return nn, nil
}

WriteString方法用于向Writer中写入字符串s

 

// ReadFrom implements io.ReaderFrom.
func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) {
	if b.Buffered() == 0 { //缓冲区为空
		if w, ok := b.wr.(io.ReaderFrom); ok { //如果wr实现了io.ReaderFrom，则调用ReadFrom将r的数据写入到w中
			return w.ReadFrom(r)
		}
	}
	var m int
	for {
		if b.Available() == 0 { //如果缓冲区已满，则调用Flush刷新缓存
			if err1 := b.Flush(); err1 != nil {
				return n, err1
			}
		}
		nr := 0
		for nr < maxConsecutiveEmptyReads {
			m, err = r.Read(b.buf[b.n:])  //将r中的数据读出的缓冲区中
			if m != 0 || err != nil { //如果有读出的数据，或者err不为nil，则跳出该for循环
				break
			}
			nr++
		}
		if nr == maxConsecutiveEmptyReads { //如果连续尝试读取了100次，都没有读出数据，则返回error
			return n, io.ErrNoProgress
		}
		b.n += m  //改变缓冲区写入的索引
		n += int64(m)
		if err != nil {
			break
		}
	}
	if err == io.EOF {
		// If we filled the buffer exactly, flush preemptively.
		if b.Available() == 0 {
			err = b.Flush()
		} else {
			err = nil
		}
	}
	return n, err
}

ReadFrom实现了io.ReaderFrom，将r中的数据读出到Writer中

 

四、bufil.ReadWriter

// buffered input and output
// ReadWriter stores pointers to a Reader and a Writer.
// It implements io.ReadWriter.
type ReadWriter struct {
	*Reader
	*Writer
}

// NewReadWriter allocates a new ReadWriter that dispatches to r and w.
func NewReadWriter(r *Reader, w *Writer) *ReadWriter {
	return &ReadWriter{r, w}
}

ReadWriter封装了bufio.Reader和bufio.Writer