bufio顧名思義，就是自帶buffer的io耐量，其內(nèi)部提供了Reader和Writer兩個(gè)struct飞蚓，通過(guò)buffer可以提升讀寫(xiě)的性能，下面看看主要的幾個(gè)讀寫(xiě)的方法

Reader

// Reader implements buffering for an io.Reader object.
// Reader結(jié)構(gòu)體
type Reader struct {
    // 緩存buffer
    buf          []byte 
    // 實(shí)現(xiàn)了io.Reader接口的變量廊蜒，比如strings.Builder等
    rd           io.Reader // reader provided by the client
    // r代表讀取標(biāo)記
    // w代表寫(xiě)入標(biāo)記
    // 這兩個(gè)標(biāo)記作用于buffer切片
    r, w         int       // buf read and write positions
    // 標(biāo)記錯(cuò)誤
    err          error
    // 記錄讀取的最后一個(gè)byte趴拧，用來(lái)做一次byte回滾
    lastByte     int // last byte read for UnreadByte; -1 means invalid
    // 記錄讀取的最后一個(gè)rune占用的字節(jié)數(shù)溅漾，用來(lái)做一次rune回滾
    lastRuneSize int // size of last rune read for UnreadRune; -1 means invalid
}

// 創(chuàng)建一個(gè)Reader
func NewReaderSize(rd io.Reader, size int) *Reader {
    // Is it already a Reader?
    // 如果rd本身就是一個(gè)Reader
    b, ok := rd.(*Reader)
    // 并且buffer也初始化過(guò)
    if ok && len(b.buf) >= size {
        return b
    }
    // buffer至少要 >= minReadBufferSize
    // minReadBufferSize = 16，即buffer最小得有16個(gè)字節(jié)的長(zhǎng)度
    if size < minReadBufferSize {
        size = minReadBufferSize
    }
    // new一個(gè)Reader
    r := new(Reader)
    // reset進(jìn)行初始化
    r.reset(make([]byte, size), rd)
    return r
}

// NewReader returns a new Reader whose buffer has the default size.
// 使用默認(rèn)的buffer長(zhǎng)度著榴，即4096個(gè)字節(jié)
func NewReader(rd io.Reader) *Reader {
    return NewReaderSize(rd, defaultBufSize)
}

// Size returns the size of the underlying buffer in bytes.
// 計(jì)算buffer的長(zhǎng)度
func (b *Reader) Size() int { return len(b.buf) }

// Reset discards any buffered data, resets all state, and switches
// the buffered reader to read from r.
// Calling Reset on the zero value of Reader initializes the internal buffer
// to the default size.
// 重置/初始化
func (b *Reader) Reset(r io.Reader) {
    // 初始化buffer
    if b.buf == nil {
        b.buf = make([]byte, defaultBufSize)
    }
    // 重置
    b.reset(b.buf, r)
}

// 重置添履，其實(shí)就是新建一個(gè)Reader
// lastByte和lastRuneSize置為-1標(biāo)記無(wú)法向前回滾一個(gè)byte/一個(gè)rune
func (b *Reader) reset(buf []byte, r io.Reader) {
    *b = Reader{
        buf:          buf,
        rd:           r,
        lastByte:     -1,
        lastRuneSize: -1,
    }
}

// fill reads a new chunk into the buffer.
// fill主要用于盡量從io.Reader中讀取字節(jié)到buffer
func (b *Reader) fill() {
    // Slide existing data to beginning.
    // [r,w-1]之間是buffer中還未被讀取走的緩存
    // 如果r > 0則說(shuō)明buffer頭部已經(jīng)被讀取過(guò)一部分
    // 這個(gè)時(shí)候?qū)r,w-1]整體往前挪，覆蓋掉已讀取的部門(mén)
    if b.r > 0 {
        copy(b.buf, b.buf[b.r:b.w])
        b.w -= b.r
        b.r = 0
    }

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

    // Read new data: try a limited number of times.
    // 這里會(huì)循環(huán)嘗試去io.Reader中讀取數(shù)據(jù)到buffer中
    // 最多會(huì)嘗試maxConsecutiveEmptyReads=100次
    for i := maxConsecutiveEmptyReads; i > 0; i-- {
        // 讀取數(shù)據(jù)脑又，寫(xiě)入到緩存的區(qū)間是[w, len(b.buf) - 1]
        n, err := b.rd.Read(b.buf[b.w:])
        // n非法直接panic
        if n < 0 {
            panic(errNegativeRead)
        }
        // 到這里 n>=0
        b.w += n
        // 如果發(fā)生錯(cuò)誤
        if err != nil {
            b.err = err
            return
        }
        // 如果n>0暮胧，說(shuō)明讀取了一部分，至于是否填充滿buffer问麸，這個(gè)不確定也不需要確定
        if n > 0 {
            return
        }
        // 到這里說(shuō)明既沒(méi)發(fā)生錯(cuò)誤往衷，又沒(méi)讀到數(shù)據(jù)(如果已經(jīng)讀取到結(jié)尾也應(yīng)該有EOF錯(cuò)誤)
        // 循環(huán)繼續(xù)嘗試
    }
    // 嘗試失敗，返回錯(cuò)誤
    b.err = io.ErrNoProgress
}

// 獲取當(dāng)前錯(cuò)誤严卖，并清空錯(cuò)誤信息
func (b *Reader) readErr() error {
    err := b.err
    b.err = nil
    return err
}

// 讀取n個(gè)字節(jié)
func (b *Reader) Peek(n int) ([]byte, error) {
    // n非法
    if n < 0 {
        return nil, ErrNegativeCount
    }
    // 每次讀取都會(huì)更新lastByte和lastRuneSize席舍，所以先置為-1
    b.lastByte = -1
    b.lastRuneSize = -1

    // 如果buffer沒(méi)填充滿并且可讀區(qū)間[r, w-1]比n還小，就得先進(jìn)行buffer填充
    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
    }

    // 如果要讀取的字節(jié)數(shù)比buffer的長(zhǎng)度還大
    // 那就直接將buffer中未讀取的數(shù)據(jù)全部返回哮笆，并給定明確的err信息
    if n > len(b.buf) {
        return b.buf[b.r:b.w], ErrBufferFull
    }

    // 0 <= n <= len(b.buf)
    var err error
    // 如果[r,w-1]的區(qū)間長(zhǎng)度小于n
    // 同樣的操作將未讀取的數(shù)據(jù)全部返回
    if avail := b.w - b.r; avail < n {
        // not enough data in buffer
        n = avail
        // 注意這里會(huì)區(qū)分返回的err信息
        // 因?yàn)橛锌赡苁窃谏厦嬲{(diào)用b.fill方法的時(shí)候產(chǎn)生的錯(cuò)誤
        err = b.readErr()
        if err == nil {
            err = ErrBufferFull
        }
    }
    return b.buf[b.r : b.r+n], err
}

// 向后丟棄n個(gè)字節(jié)来颤，并返回實(shí)際丟棄的字節(jié)數(shù)
func (b *Reader) Discard(n int) (discarded int, err error) {
    // n非法
    if n < 0 {
        return 0, ErrNegativeCount
    }
    // 等于沒(méi)丟
    if n == 0 {
        return
    }

    // 同上
    b.lastByte = -1
    b.lastRuneSize = -1

    // remain標(biāo)示剩余要跳過(guò)的字節(jié)數(shù)
    remain := n
    // 這里會(huì)循環(huán)跳過(guò)
    // 即如果單次跳過(guò)后buffer已經(jīng)空了并且跳過(guò)的字節(jié)數(shù)<n，就會(huì)繼續(xù)填充buffer繼續(xù)跳過(guò)
    for {
        // 這里取的就是區(qū)間[r,w-1]的長(zhǎng)度即w-r
        skip := b.Buffered()
        // 如果未讀取空間是空的
        // 調(diào)用b.fill填充
        if skip == 0 {
            b.fill()
            skip = b.Buffered()
        }
        // 如果未讀空間足夠跳過(guò)n個(gè)字節(jié)
        if skip > remain {
            skip = remain
        }
        // 跳過(guò)后調(diào)整r的位置
        b.r += skip
        // 更新剩余要跳過(guò)的字節(jié)數(shù)
        remain -= skip
        // 如果不需要跳過(guò)了稠肘，則返回
        if remain == 0 {
            return n, nil
        }
        // 如果發(fā)生了錯(cuò)誤福铅，則返回實(shí)際跳過(guò)的字節(jié)數(shù)和對(duì)應(yīng)的錯(cuò)誤
        if b.err != nil {
            return n - remain, b.readErr()
        }
    }
}

// 讀取數(shù)據(jù)到p中，并返回實(shí)際讀取的數(shù)據(jù)的字節(jié)數(shù)
func (b *Reader) Read(p []byte) (n int, err error) {
    n = len(p)
    // p是空的
    if n == 0 {
        if b.Buffered() > 0 {
            return 0, nil
        }
        return 0, b.readErr()
    }
    // 如果buffer是空的
    if b.r == b.w {
        // 有錯(cuò)誤
        if b.err != nil {
            return 0, b.readErr()
        }
        // 要讀取的字節(jié)數(shù)比buffer的長(zhǎng)度大
        if len(p) >= len(b.buf) {
            // Large read, empty buffer.
            // Read directly into p to avoid copy.
            // 也就是說(shuō)如果通過(guò)fill填滿buffer项阴，也會(huì)立即將buffer的數(shù)據(jù)全部讀取到p中
            // 沒(méi)必要倒兩手滑黔，直接從io.Reader讀到p
            n, b.err = b.rd.Read(p)
            // n非法，panic
            if n < 0 {
                panic(errNegativeRead)
            }
            // 更新lastByte和lastRuneSize
            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.
        // 到這里就會(huì)先讀取到buffer中
        // 也就是說(shuō)本次不會(huì)把buffer中的數(shù)據(jù)全部讀完鲁冯，后續(xù)再讀可以直接從buffer讀拷沸，就不用從io.Reader中讀了，速度自然就快了
        b.r = 0
        b.w = 0
        // 這里沒(méi)有用fill去操作薯演，原因是這是由使用方觸發(fā)的一次讀取
        // 成功就成功撞芍，失敗就失敗，保證讀取速度
        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
    // Note: if the slice panics here, it is probably because
    // the underlying reader returned a bad count. See issue 49795.
    // 到這里就將buffer中的可讀取的數(shù)據(jù)讀取到p中跨扮，可能填滿p也可能填不滿p序无，這都是正常的
    // 使用的時(shí)候要注意，這里如果p沒(méi)有被填滿衡创，并不代表讀取完了io.Reader中的數(shù)據(jù)帝嗡，只是讀取完了buffer中的數(shù)據(jù)
    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還實(shí)現(xiàn)了其他的一些方法，這里不一一詳細(xì)說(shuō)了璃氢，目的主要是為了介紹下io.Reader在有buffer的輔助下是怎么加快讀性能以及如何管理buffer的哟玷，同時(shí)介紹下Reader的設(shè)計(jì)思路和常用/底層的方法

Writer

// Writer結(jié)構(gòu)
type Writer struct {
    // 錯(cuò)誤信息
    err error
    // buffer
    buf []byte
    // 寫(xiě)入位置
    n   int
    // 實(shí)現(xiàn)了io.Writer接口的變量
    wr  io.Writer
}

// 創(chuàng)建一個(gè)Writer
func NewWriterSize(w io.Writer, size int) *Writer {
    // Is it already a Writer?
    // 如果自身就是Writer
    b, ok := w.(*Writer)
    // 并且buffer已經(jīng)初始化了
    if ok && len(b.buf) >= size {
        return b
    }
    // 如果buffer沒(méi)有初始化
    if size <= 0 {
        size = defaultBufSize
    }
    // 構(gòu)造Writer
    // 默認(rèn)n=0，即從buffer[0]開(kāi)始寫(xiě)入
    return &Writer{
        buf: make([]byte, size),
        wr:  w,
    }
}

// 使用defaultBufSize創(chuàng)建Writer
func NewWriter(w io.Writer) *Writer {
    return NewWriterSize(w, defaultBufSize)
}

// 獲取buffer的長(zhǎng)度
func (b *Writer) Size() int { return len(b.buf) }

// Reset discards any unflushed buffered data, clears any error, and
// resets b to write its output to w.
// Calling Reset on the zero value of Writer initializes the internal buffer
// to the default size.
// 重置/初始化Writer
func (b *Writer) Reset(w io.Writer) {
    // 初始化buffer
    if b.buf == nil {
        b.buf = make([]byte, defaultBufSize)
    }
    b.err = nil
    b.n = 0
    b.wr = w
}


// Flush writes any buffered data to the underlying io.Writer.
// 將buffer的數(shù)據(jù)刷到io.Writer中
func (b *Writer) Flush() error {
    // 如果有錯(cuò)誤
    if b.err != nil {
        return b.err
    }
    // 如果buffer為空
    if b.n == 0 {
        return nil
    }
    // 將buffer的數(shù)據(jù)刷到io.Writer中
    // 這里只需要維護(hù)buffer的寫(xiě)入位置n即可，因?yàn)槠鹗嘉恢檬冀K都是0
    // 這點(diǎn)不同于Reader
    n, err := b.wr.Write(b.buf[0:b.n])
    // 如果未發(fā)生錯(cuò)誤并且buffer中的數(shù)據(jù)沒(méi)有全部刷到io.Writer中
    if n < b.n && err == nil {
        err = io.ErrShortWrite
    }
    // 如果發(fā)生錯(cuò)誤
    if err != nil {
        // buffer未刷空
        if n > 0 && n < b.n {
            // 將未刷的數(shù)據(jù)往前挪覆蓋刷過(guò)的數(shù)據(jù)
            // 這就保證了每次起始位置都是0巢寡，也是為什么只需要維護(hù)一個(gè)n的原因
            copy(b.buf[0:b.n-n], b.buf[n:b.n])
        }
        // 更新寫(xiě)入位置
        b.n -= n
        b.err = err
        return err
    }
    // 到這里說(shuō)明err == nil && n = b.n
    // 也就是buffer刷空了
    // 重新開(kāi)始從buffer[0]寫(xiě)入
    b.n = 0
    return nil
}


// Available returns how many bytes are unused in the buffer.
// 返回buffer中可寫(xiě)入的字節(jié)數(shù)
func (b *Writer) Available() int { return len(b.buf) - b.n }

// AvailableBuffer returns an empty buffer with b.Available() capacity.
// This buffer is intended to be appended to and
// passed to an immediately succeeding Write call.
// The buffer is only valid until the next write operation on b.
// 返回buffer中可寫(xiě)入的切片區(qū)間
func (b *Writer) AvailableBuffer() []byte {
    return b.buf[b.n:][:0]
}

// Buffered returns the number of bytes that have been written into the current buffer.
// 返回b.n喉脖，即已寫(xiě)入到buffer的字節(jié)數(shù)
func (b *Writer) Buffered() int { return b.n }

// 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.
// 將字節(jié)切片p寫(xiě)入到Writer中，并返回實(shí)際寫(xiě)入的字節(jié)數(shù)
func (b *Writer) Write(p []byte) (nn int, err error) {
    // 如果buffer沒(méi)有足夠的空間放下p
    for len(p) > b.Available() && b.err == nil {
        var n int
        // 如果buffer是空的
        // 加上前面的條件說(shuō)明抑月，len(p) > len(b.buf)
        // 那就不倒到buffer了树叽，直接寫(xiě)到io.Writer中
        if b.Buffered() == 0 {
            // Large write, empty buffer.
            // Write directly from p to avoid copy.
            n, b.err = b.wr.Write(p)
        } else {
            // 否則就將p的一部分寫(xiě)到buffer中，然后觸發(fā)Flush將buffer整個(gè)刷到io.Writer中
            n = copy(b.buf[b.n:], p)
            b.n += n
            b.Flush()
        }
        // 更新統(tǒng)計(jì)寫(xiě)入的字節(jié)數(shù)
        nn += n
        // 更新p
        p = p[n:]
    }
    // 如果發(fā)生錯(cuò)誤
    if b.err != nil {
        return nn, b.err
    }
    // 到這里說(shuō)明buffer已經(jīng)有足夠的空間存在p了
    // 不用在觸發(fā)Flush谦絮，等下次滿的時(shí)候再觸發(fā)题诵，減少io.Writer的次數(shù)，加快寫(xiě)性能
    // 所以這里需要注意层皱，Write并不一定會(huì)把寫(xiě)入的數(shù)據(jù)都刷到io.Writer中性锭，所以如果想要馬上寫(xiě)入到io.Writer，記得手動(dòng)調(diào)用一次Flush
    n := copy(b.buf[b.n:], p)
    b.n += n
    nn += n
    return nn, nil
}

// WriteString writes a string.
// It returns the number of bytes written.
// If the count is less than len(s), it also returns an error explaining
// why the write is short.
// 將字符串s寫(xiě)入到Writer中
func (b *Writer) WriteString(s string) (int, error) {
    nn := 0
    // 同樣的操作叫胖，判斷buffer是否有空間存入s
    for len(s) > b.Available() && b.err == nil {
        // 這里沒(méi)有像Write一樣直接將s寫(xiě)入到io.Writer中
        // 個(gè)中原因能還是需要先將s轉(zhuǎn)成[]byte篷店，這跟將s拷貝到buffer中幾乎是一樣的
        // 所以就不需要再細(xì)化判斷條件搞得還復(fù)雜了
        n := copy(b.buf[b.n:], s)
        b.n += n
        nn += n
        s = s[n:]
        b.Flush()
    }
    // 下面基本跟Write也是一樣的
    if b.err != nil {
        return nn, b.err
    }
    n := copy(b.buf[b.n:], s)
    b.n += n
    nn += n
    return nn, nil
}

Writer還實(shí)現(xiàn)了一些其他的方法，這里也不多說(shuō)了臭家，原理清楚了即可

ReadWriter

// 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}
}

bufio還提供了一個(gè)同時(shí)包含Reader和Writer的結(jié)構(gòu)體以及對(duì)應(yīng)的創(chuàng)建方法

總結(jié)

bufio通過(guò)buffer來(lái)減少操作io.Reader和io.Writer的次數(shù)，從而提升性能方淤，這種優(yōu)化方式比比皆是钉赁，比如底層的cpu的緩存，應(yīng)用層的mysql緩存等等