golang的bufio源码分析

原本只想用用bufio，但是网上文章没有一个写清楚bufio到底怎么用，每个方法具体干了什么，搞不明白原理就不敢乱用，还好有源码，自己来分析最清楚。

Reader分析

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 { //minReadBufferSize==16
        size = minReadBufferSize
    }
    r := new(Reader)
    r.reset(make([]byte, size), rd)
    return r
}

// NewReader returns a new Reader whose buffer has the default size.
func NewReader(rd io.Reader) *Reader {
    return NewReaderSize(rd, defaultBufSize)
}

一开始传入io.Reader创建bufio.Reader，默认defaultBufSize为4096字节也就是4K字节。

// fill reads a new chunk into the buffer.
func (b *Reader) fill() {
    // Slide existing data to beginning.
    if b.r > 0 { //把buf剩余可读的数据复制到最前
        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")
    }
    //maxConsecutiveEmptyReads == 100
    // Read new data: try a limited number of times.
    for i := maxConsecutiveEmptyReads; i > 0; i-- {
        n, err := b.rd.Read(b.buf[b.w:]) //从io中读取数据写入缓存 
        if n < 0 {
            panic(errNegativeRead)
        }
        b.w += n //更新写入缓存的长度
        if err != nil {
            b.err = err
            return
        }
        if n > 0 {
            return
        }
              // n== 0时会循环尝试从io中读取，最多100次
    }
    b.err = io.ErrNoProgress //读了100次，n都为0
}

fill()把剩余未读长度的数据复制到缓存头部并且r重置为0，相当于把未读数据移动到头部。同时尽量从io中读取数据写入缓存，有可能不能写满。

// ReadByte reads and returns a single byte.
// If no byte is available, returns an error.
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，从io中fill数据
    }
    c := b.buf[b.r]//此时肯定有数据了，取r位置的一个字节
    b.r++ //r游标移动一个字节
    b.lastByte = int(c)
    return c, nil
}

ReadByte()从缓存中读取一个字节，如果缓存中没有数据则尝试从io中填充数据。最后返回读取到的一个字节的内容


// 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) { //p的空间大于等于缓存
            // Large read, empty buffer.
            // Read directly into p to avoid copy.
            n, b.err = b.rd.Read(p)//直接从io中把数据读取到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.
        // 无数据可读，表示buf中数据无用了则重置r和w的游标
        b.r = 0
        b.w = 0
        n, b.err = b.rd.Read(b.buf)//从io中读取到缓存
        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])//缓存中数据可读数据读取到p
    b.r += n //读了多少
    b.lastByte = int(b.buf[b.r-1])
    b.lastRuneSize = -1
    return n, nil
}

Read(p []byte)：
当缓存中没有可读数据时有两种情况：
情况1. 当p的空间大于等于缓存时，直接从io中把数据读取到p。
情况2. 当p的空间小于缓存时，重置缓存游标，尽量从io中读取数据到缓存，然后再从缓存中复制到p里。

当缓存中有可读数据时，直接从缓存中把可读数据复制到p中，此时不会去读取io。

p的空间有可能被填满，也有可能不满，返回的n说明读取了多少个字节。

// 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.
func (b *Reader) Peek(n int) ([]byte, error) {
    if n < 0 {
        return nil, ErrNegativeCount
    }

    //剩余可读小于n而且小于缓存时从io里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
    }
    //n比缓存大，返回可读的缓存切片，而且错误值为ErrBufferFull
    if n > len(b.buf) {
        return b.buf[b.r:b.w], ErrBufferFull
    }

    // 0 <= n <= len(b.buf)
    var err error
    if avail := b.w - b.r; avail < n {
        // not enough data in buffer
        //缓存的可读数据不够读，返回可以读的缓存切片及错误值ErrBufferFull
        n = avail
        err = b.readErr()
        if err == nil {
            err = ErrBufferFull
        }
    }
    //如果缓存的可读数据足够就返回可读缓存切片和空错误
    return b.buf[b.r : b.r+n], err
}

Peek(n int)：
先从io中填充缓存。
如果要读的n比缓存大返回错误值ErrBufferFull。
如果n小于等于缓存，且可读数据不够读返回ErrBufferFull或者io读错误。
如果有可够读的数据返回的错误为空。

不管怎样都会返回缓存可读取的切片但是没有移动读游标，修改返回的切片会影响缓存中的数据。

// Buffered returns the number of bytes that can be read from the current buffer.
func (b *Reader) Buffered() int { return b.w - b.r }//可读长度

// 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
    }
    remain := n
    for {
        skip := b.Buffered()
        if skip == 0 {//没可读先fill填充
            b.fill()
            skip = b.Buffered()
        }
        if skip > remain {
            skip = remain
        }
        b.r += skip //读游标直接跳过skip个字节
        remain -= skip
        if remain == 0 {//成功跳过请求的字节长度
            return n, nil
        }
        if b.err != nil {//出错了，返回剩下多少个字节没跳过和错误
            return n - remain, b.readErr()
        }
    }
}

Discard(n int) ：
跳过n个字节不读取，一直循环到成功跳过或者出现错误。

Reader的其他方法我一般不用，所以也不分析了。

总结：

Peek返回错误不为空时，一种情况是你Peek的长度比缓存都大，那么数据永远不够，所以传入参数时要注意别比缓存大。
别一种情况是，从io里尝试读数据了但还是准备不够你需要的长度，比如网络tcp的数据一开始没有到达，等下一轮你再调用Peek时可能缓存就足够你读了。
其实就算有错误也会返回你可读取的切片。
如果错误为空，恭喜你，数据都准备好啦。
Peek不会移动读游标，如果直接使用Peek返回的切片可以配合Discard来跳过指定字节的数据不再读取也就是移动读游标。

Read尽量先从缓存中读取数据。当前缓存无数据可读时先从io中读取填充到缓存里，然后从缓存中复制。返回读取到的数据长度不一定，小于或者等于Read要求的长度。

想跳过n个字节不读取，使用Discard。

使用NewReader初始化时默认缓存为4096字节，在某些情况下可能太大浪费内存或者太小不够用，最好还是使用NewReaderSize根据情况自定义缓存大小。

Writer

有空再写