详解golang中bufio包的实现原理

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

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

// Writer implements buffering for an io.Writer object.
type Writer struct {
  err error
  buf []byte
  n  int
  wr io.Writer
}

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