|  | 
 
| 今天写程序的时候碰到这么一个问题。 
 有两个线程,一个在读一个BUF,另一个在写这个BUF。
 
 最开始的做法是这样的:
 定义一个尾指针,每次写的时候都往尾指针里面写,读的时候就从头读,读完之后把剩下没读完的重新拷贝到头,并修改尾指针。
 
 考虑到每次读的时候都需要使用到内存拷贝(memcpy),于是想了办法,用环型内存来处理。
 
 需要两个指针,一个叫小偷(thief_ptr),另一个叫警察(police_ptr),其中小偷扮演写的角色,警察则扮演读的角色。那么实际上就是在一个环型跑道上警察追小偷的过程,小偷永远在警察前面,但是不能超过警察一圈以上。
 
 这里还有个细节问题需要处理,就是当小偷跑到起跑线的时候(内存边界)当步长超过余下的内存的时候,即
 
 step_lenth > max_buffer_len - thief_ptr
 
 也就是说要写入数据的长度大于剩下的空间的时候,这个时候,跑道的大小是可以改变的,我让这一圈跑道的长度设置为小偷在临界区时候的步长,这样就可以有效的解决这种问题。
 
 经测试,该方法的效率比每次都memcpy的效率要高10%左右,由于是网络层引擎的比较核心的地方,所以10%的效率能带来非常大的改变。
 
 以下是实现伪代码:
 
 // 设置为双倍大小,有利于每一圈跑道的变长
 unsigned char buf[BUF_SIZE * 2];
 unsigned char *thief_ptr;
 unsigned char *police_ptr;
 int racetrack_len;
 // 判断警察和小偷是否在同一圈内,界线是起跑线
 bool InCatchCycle;
 
 void Init()
 {
 // 警察和小偷在同一起跑线上
 thief_ptr = police_ptr = buf;
 // 警察和小偷一开始都在同一圈内
 InCatchCycle = true;
 }
 
 bool CheckWriteable(int len)
 {
 //如果不在同一圈内,小偷就不能超过警察
 if((!InCatchCycle && (police_ptr - thief_ptr < len)) )
 return false;
 return true;
 }
 
 int SendMsg(const unsigned char *msg, const int &len)
 {
 if(!CheckWriteable(len) || len > BUF_SIZE)
 return 0;
 
 // 此处要接收消息,无奈,只能使用memcpy
 memcpy(thief_ptr, msg, len);
 
 // 警察和小偷不在同一圈内
 if(!InCatchCycle || (BUF_SIZE - (thief_ptr - buf) >= len))
 {
 //小偷跑len步长
 thief_ptr += len;
 return 1;
 }
 
 // 修正这一圈的长度
 racetrack_len = (thief_ptr - WBuf) + len;
 // 跑完一圈,回到终点
 thief_ptr = buf;
 // 小偷这个时候和警察肯定不在同一圈内
 InCatchCycle = false;
 return 1;
 }
 
 int ReadMsg()
 {
 int len;
 
 //如果警察和小偷在同一圈内,则计算警察和小偷之间差多远
 if(InCatchCycle) len = thief_ptr - police_ptr;
 //否则则算警察离修正过的终点还差多远
 else len = racetrack_len - (police_ptr - buf);
 
 if(len <= 0) return 0;
 
 int n;
 // 因为很多因素,n大多数情况下不等于len
 // 特别是在网络情况下。
 n = get_msg(police_ptr, len);
 //警察跑n步长
 police_ptr += n;
 if(n == len && !InCatchCycle){
 //如果警察跑完一圈,回到起点
 police_ptr = WBuf;
 //这个时候警察和小偷肯定在同一圈了
 InCatchCycle = true;
 }
 
 return n;
 }
 | 
 |