环型内存的实现。

有两个线程，一个在读一个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;
}

本文地址：http://com.8s8s.com/it/it35561.htm