go 实现ringbuffer以及ringbuffer使用场景介绍

2023/6/5 18:23:58

本文主要是介绍go 实现ringbuffer以及ringbuffer使用场景介绍,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

ringbuffer因为它能复用缓冲空间,通常用于网络通信连接的读写,虽然市面上已经有了go写的诸多版本的ringbuffer组件,虽然诸多版本,实现ringbuffer的核心逻辑却是不变的。但发现其内部提供的方法并不能满足我当下的需求,所以还是自己造一个吧。

源码已经上传到github

https://github.com/HobbyBear/ringbuffer

需求分析

我在基于epoll实现一个网络框架时,需要预先定义好的和客户端的通信协议,当从连接读取数据时需要判读当前连接是否拥有完整的协议(实际网络环境中可能完整的协议字节只到达了部分),有才会将数据全部读取出来,然后进行处理,否则就等待下次连接可读时,再判断连接是否具有完整的协议。

由于在读取时需要先判断当前连接是否有完整协议,所以读取时不能移动读指针的位置,因为万一协议不完整的话,下次读取还要从当前的读指针位置开始读取。

所以对于ringbuffer 组件我会实现一个peek方法

func (r *RingBuffer) Peek(readOffsetBack, n int) ([]byte, error)

peek方法两个参数,n代表要读取的字节数, readOffsetBack 代表读取是要在当前读位置偏移的字节数,因为在设计协议时,往往协议不是那么简单(可能是由多个固定长度的数据构成) ,比如下面这样的协议格式。

image.png

完整的协议有三段构成,每段开头都会有一个4字节的大小代表每段的长度,在判断协议是否完整时,就必须看着3段的数据是否都全部到达。 所以在判断第二段数据是否完整时,会跳过前面3个字节去判断,此时readOffsetBack 将会是3。

此外我还需要一个通过分割符获取字节的方法,因为有时候协议不是固定长度的数组了,而是通过某个分割符判断某段协议是否结束,比如换行符。

func (r *RingBuffer) PeekBytes(readOffsetBack int, delim byte) ([]byte, error) 

接着,还需要提供一个更新读位置的方法,因为一旦判断是一个完整的协议后,我会将协议数据全部读取出来,此时应该要更新读指针的位置,以便下次读取新的请求。

func (r *RingBuffer) AddReadPosition(n int) 

n 便是代表需要将读指针往后偏移的n个字节。

ringbuffer 原理解析

接着,我们再来看看实际上ringbuffer的实现原理是什么。

首先来看下一个ringbuffer应该有的属性

type RingBuffer struct {  
   buf             []byte  
   reader          io.Reader  
   r               int // 标记下次读取开始的位置  
   unReadSize      int // 缓冲区中未读数据大小  
}

buf 用作连接读取的缓冲区,reader 代表了原链接,r代表读取ringbuffer时应该从字节数组的哪个位置开始读取,unReadSize 代表缓冲区当中还有多少数据没有读取,因为你可能一次性从reader里读取了很多数据到buf里,但是上层应用只取buf里的部分数据,剩余的未读数据就留在了buf里,等待下次被应用层继续读取。

我们用一个5字节的字节数组当做缓冲区, 首先从ringbuffer读取数据时,由于ringbuffer内部没有数据,所以需要从连接中读取数据然后写到ringbuffer里。

如下图所示:

假设ringBuffer规定每次向原网络连接读取时 按4字节读取到缓冲区中(实际情况为了减少系统调用开销,这个值会更多,尽可能会一次性读取更多数据到缓冲区) write pos 指向的位置则代表从reader读取的数据应该从哪个位置开始写入到buf字节数组里。

writePos = (r + unReadSize) % len(buf)

image.png
接着,上层应用只读取了3个字节,缓冲区中的读指针r和未读空间就会变成下面这样

image.png

如果此时上层应用还想再读取3个字节,那么ringbuffer就必须再向reader读取字节填充到缓冲区上,我们假设这次向reader索取3个字节。缓冲区的空间就会变成下面这样

image.png
此时已经复用了首次向reader读取数据时占据的缓冲空间了。

当填充上字节后,应用层继续读取3个字节,那么ringBuffer会变成这样

image.png

读指针又指向了数组的开头了,可以得出读指针的计算公式

r = (r + n)% len(buf)

ringBuffer 代码解析

有了前面的演示后,再来看代码就比较容易了。用peek 方法举例进行分析,

func (r *RingBuffer) Peek(readOffsetBack, n int) ([]byte, error) { 
   // 由于目前实现的ringBuffer还不具备自动扩容,所以不支持读取的字节数大于缓冲区的长度
   if n > len(r.buf) {  
      return nil, fmt.Errorf("the unReadSize is over range the buffer len")  
   }  
peek:  
   if n <= r.UnReadSize()-readOffsetBack {  
      // 说明缓冲区中的未读字节数有足够长的n个字节,从buf缓冲区直接读取
      readPos := (r.r + readOffsetBack) % len(r.buf)  
      return r.dataByPos(readPos, (r.r+readOffsetBack+n-1)%len(r.buf)), nil  
   }  
   // 说明缓冲区中未读字节数不够n个字节那么长,还需要从reader里读取数据到缓冲区中
   err := r.fill()  
   if err != nil {  
      return nil, err  
   }  
   goto peek  
}

peek方法的大致逻辑是首先判断要读取的n个字节能不能从缓冲区buf里直接读取,如果能则直接返回,如果不能,则需要从reader里继续读取数据,直到buf缓冲区数据够n个字节那么长。

dataByPos 方法是根据传入的元素位置,从buf中读取在这个位置区间内的数据。

// dataByPos 返回索引值在start和end之间的数据,闭区间  
func (r *RingBuffer) dataByPos(start int, end int) []byte {  
   // 因为环形缓冲区原因,所以末位置索引值有可能小于开始位置索引  
   if end < start {  
      return append(r.buf[start:], r.buf[:end+1]...)  
   }  
   return r.buf[start : end+1]  
}

fill() 方法则是从reader中读取数据到buf里。

fill 情况分析

reader填充新数据到buf后,未读空间未跨越buf末尾

image.png
当从reader读取完数据后,如果 end := r.r + r.unReadSize + readBytes end指向了未读空间的末尾,如果没有超过buf的长度,那么将数据复制到buf里的逻辑很简单,直接在当前write pos的位置追加读取到的字节就行。

// 此时writePos 没有超过 len(buf)
writePos = (r + unReadSize)

未读 空间 本来就 已经从头覆盖

当未读空间本来就重新覆盖了buf头部,和上面类似,这种情况也是直接在write pos 位置追加数据即可。

image.png

未读空间未跨越buf末尾,当从reader追加数据到buf后发现需要覆盖buf头部

image.png
这种情况需要将读取的数据一部分覆盖到buf的末尾

 writePos := (r.r + r.unReadSize) % len(r.buf)  
 n := copy(r.buf[writePos:], buf[:readBytes])  

一部分覆盖到buf的头部

end := r.r + r.unReadSize + readBytes  
copy(r.buf[:end%len(r.buf)], buf[len(r.buf)-writePos:])  

现在再来看fill的源码就比较容易理解了。

func (r *RingBuffer) fill() error {  
   if r.unReadSize == len(r.buf) {  
      // 当未读数据填满buf后 ,就应该等待上层应用把未读数据读取一部分再来填充缓冲区
      return fmt.Errorf("the unReadSize is over range the buffer len")  
   }  
   // batchFetchBytes 为每次向reader里读取多少个字节,如果此时buf的剩余空间比batchFetchBytes小,则应该只向reader读取剩余空间的字节数
   readLen := int(math.Min(float64(r.batchFetchBytes), float64(len(r.buf)-r.unReadSize)))  
   buf := make([]byte, readLen)  
   readBytes, err := r.reader.Read(buf)  
   if readBytes > 0 {  
     // 查看读取readBytes个字节后,未读空间有没有超过buf末尾指针,如果超过了,在复制数据时需要特殊处理
      end := r.r + r.unReadSize + readBytes  
      if end < len(r.buf) {
        // 没有超过末尾指针,直接将数据copy到writePos后面  
         copy(r.buf[r.r+r.unReadSize:], buf[:readBytes])  
      } else {  
        // 超过了末尾指针,有两种情况,看下图分析
         writePos := (r.r + r.unReadSize) % len(r.buf)  
         n := copy(r.buf[writePos:], buf[:readBytes])  
         if n < readBytes {  
            copy(r.buf[:end%len(r.buf)], buf[len(r.buf)-writePos:])  
         }  
      }  
      r.unReadSize += readBytes  
      return nil  
   }  
   if err != nil {  
      return err  
   }  
   return nil  
}


这篇关于go 实现ringbuffer以及ringbuffer使用场景介绍的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程