golang bufio解析

虚幻大学 xuhss 230℃ 0评论

? 优质资源分享 ?

学习路线指引(点击解锁) 知识定位 人群定位
? Python实战微信订餐小程序 ? 进阶级 本课程是python flask+微信小程序的完美结合,从项目搭建到腾讯云部署上线,打造一个全栈订餐系统。
?Python量化交易实战? 入门级 手把手带你打造一个易扩展、更安全、效率更高的量化交易系统

golang bufio

目录* golang bufio

当频繁地对少量数据读写时会占用IO,造成性能问题。golang的bufio库使用缓存来一次性进行大块数据的读写,以此降低IO系统调用,提升性能。

在Transport中可以设置一个名为WriteBufferSize的参数,该参数指定了底层(Transport.dialConn)写buffer的大小。

    tr := &http.Transport{
        WriteBufferSize:     64 * 1024,
    }
    pconn.br = bufio.NewReaderSize(pconn, t.readBufferSize())
    pconn.bw = bufio.NewWriterSize(persistConnWriter{pconn}, t.writeBufferSize())

使用bufio进行写

可以使用bufio.NewWriter初始化一个大小为4096字节的Writer(见下),或使用bufio.NewWriterSize初始化一个指定大小的Writer

Writer中的主要参数为缓存区buf,缓存区中的数据偏移量n以及写入接口wr

type Writer struct {
    err error
    buf []byte
    n   int
    wr  io.Writer
}

bufio.Writer方法可以一次性写入缓存中的数据,通常有如下三种情况:

  1. 缓存中满数据
  2. 缓存中仍有空间
  3. 待写入的数据大于缓存的大小

缓存中满数据

当缓存中满数据时,会执行写操作。

缓存中仍有空间

如果缓存中仍有数据,则不会执行写入动作,除非调用Flush()方法。

待写入的数据大于缓存的大小

由于此时缓存无法缓存足够的数据,此时会跳过缓存直接执行写操作

type Writer int

func (*Writer) Write(p []byte) (n int, err error) {
    fmt.Printf("Writing: %s\n", p)
    return len(p), nil
}

func main() {
    w := new(Writer)
    bw1 := bufio.NewWriterSize(w, 4)

    // Case 1: Writing to buffer until full
    bw1.Write([]byte{'1'})
    bw1.Write([]byte{'2'})
    bw1.Write([]byte{'3'})
    bw1.Write([]byte{'4'}) // write - buffer is full

    // Case 2: Buffer has space
    bw1.Write([]byte{'5'}) //此时buffer中无法容纳更多的数据,执行写操作,写入 []byte{'1','2','3','4'}
    err = bw1.Flush() // forcefully write remaining
    if err != nil {
        panic(err)
    }

    // Case 3: (too) large write for buffer
    // Will skip buffer and write directly
    bw1.Write([]byte("12345")) //buffer不足,直接执行写操作
}

//结果:
Writing: 1234
Writing: 5
Writing: 12345

缓存重用

申请缓存对性能是有损耗的,可以使用Reset方法重置缓存,其内部只是将Writer的数据偏移量n置0。

wr := new(Writer)
bw := bufio.NewWriterSize(wr,2) 
bw.Reset(wr) 

获取缓存的可用空间数

Available()方法可以返回缓存的可用空间数,即len(Writer.buf)-Writer.n

使用bufio进行读

与用于写数据的Writer类似,读数据也有一个Reader,可以使用NewReader初始化一个大小为4096字节的Reader,或使用NewReaderSize初始化一个指定大小的Reader(要求最小字节为16)。Reader也有一个记录偏移量的变量r

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
}

Peek

该方法会返回buf中的前n个字节的内容,但与Read操作不同的是,它不会消费缓存中的数据,即不会增加数据偏移量,因此通常也会用于判断是否读取结束(EOF)。通常有如下几种情况:

  1. 如果peak的值小于缓存大小,则返回相应的内容
  2. 如果peak的值大于缓存大小,则返回bufio.ErrBufferFull错误
  3. 如果peak的值包含EOF且小于缓存大小,则返回EOF

Read

将数据读取到p,涉及将数据从缓存拷贝到p

func (b *Reader) Read(p []byte) (n int, err error)

ReadSlice

该方法会读从缓存读取数据,直到遇到第一个delim。如果缓存中没有delim,则返回EOF,如果查询的长度超过了缓存大小,则返回 io.ErrBufferFull 错误。

func (b *Reader) ReadSlice(delim byte) (line []byte, err error) 

例如delim',',则下面会返回的内容为1234,

func main() {
    r := strings.NewReader("1234,567")
    rb := bufio.NewReaderSize(r, 20)
    fmt.Println(rb.ReadSlice(','))
}

// 结果:[49 50 51 52 44] 

注意:ReadSlice返回的是原始缓存中的内容,如果针对缓存作并发操作,则返回的内容有可能被其他操作覆盖。因此在官方注释里面有写,建议使用ReadBytesReadString。但ReadBytesReadString涉及内存申请和拷贝,因此会影响性能。在追求高性能的场景下,建议外部使用sync.pool来提供缓存。

// Because the data returned from ReadSlice will be overwritten
// by the next I/O operation, most clients should use
// ReadBytes or ReadString instead.

ReadLine

ReadLine() (line []byte, isPrefix bool, err error)

ReadLine底层用到了ReadSlice,但在返回时会移除\n\r\n。需要注意的是,如果切片中没有找到换行符,则不会返回EOF或io.ErrBufferFull 错误,相反,它会将isPrefix置为true

ReadBytes

ReadSlice类似,但它会返回一个新的切片,因此便于并发使用。如果找不到delimReadBytes会返回io.EOF

func (b *Reader) ReadBytes(delim byte) ([]byte, error)

Scanner

scanner可以不断将数据读取到缓存(默认64*1024字节)。

func main() {
    rb := strings.NewReader("12345678901234567890")
    scanner := bufio.NewScanner(rb)
    for scanner.Scan() {
        fmt.Printf("Token (Scanner): %q\n", scanner.Text())
    }
}

// 结果:Token (Scanner): "12345678901234567890"

并发复用缓存

io.bufio支持缓存读写以及Reset操作,但在并发复用缓存方面做的不是很好,可以参考:victoriaMetrics之byteBuffer

无需并发复用的话,用io.bufio即可。

限制从io.Reader中读取的数据量

方式1

使用io.LimitReader来限制从Reader中读取的数据量,LimitedReader.N给出了可读取的剩余数据量。一旦N变为0,即时Reader中仍然有数据,此时也会返回EOF

type LimitedReader struct {
   R Reader // underlying reader
   N int64  // max bytes remaining
}
func main() {
    rb := strings.NewReader("12345678901234567890")

    lr := io.LimitReader(rb, 3)//限制可以读取3个字节的数据
    buf := make([]byte, 400)
    fmt.Println(lr.Read(buf)) //达到读取上限制,LimitedReader.N=0
    fmt.Println(lr.Read(buf)) //此时返回EOF
}

//结果
3 <nil>
0 EOF
方式2

可以使用io.CopyN限制从Reader读取的数据量,它内部也使用了io.LimitReader,但支持多次读取。

type Writer int

func (*Writer) Write(p []byte) (n int, err error) {
    fmt.Printf("Writing: %s\n", p)
    return len(p), nil
}

func main() {
    rb := strings.NewReader("12345678901234567890")

    w := new(Writer)
    fmt.Println(io.CopyN(w, rb, 6))
    fmt.Println(io.CopyN(w, rb, 6))
}

//结果
Writing: 123456
6 <nil>
Writing: 789012
6 <nil>

参考

how-to-read-and-write-with-golang-bufio

转载请注明:xuhss » golang bufio解析

喜欢 (0)

您必须 登录 才能发表评论!