在网络服务器的设计中,经常使用多进程/多线程.这就涉及到在进程/线程间共享数据.
现在我们假设一个场景,一个进程/线程负责处理网络收发,一个或多个进程/线程处理
收到的网络数据包.
显然,我们可以在每一对协作进程/线程间添加一个队列,将数据添加到队列中,以实现
两个进程/线程的协作.
我们的消息队列主要的设计目标有三个:
1)要可以使用在进程与进程和线程与线程之间.当在进程之间通信时,我们的消息队列
将会被放在共享内存中.
2)避免使用锁机制,其一方面原因是锁的开销较大,另一方面是因为,对于在共享内存中
使用消息队列时.如果一个进程获得锁之后崩溃,另一个进程将得不到任何的通知.当它
要获得锁的时候,将会阻塞在永远不会被释放的锁上(unix like的系统).
3)可向队列中加入变长的消息,减少memcopy的次数.
基于以上目标,每一个消息队列只能有一个写者,一个读者,以避免锁的使用.
消息队列用数组实现循环队列.数组中的每个元素是以下结构:
template<int MsgSize> struct msgBlock { int next; //下一个块的下标,如果是最后一个block,则==-1 int totalSize;//整个消息的大小,仅对消息中的第一个块有效 int size; //本块有效数据大小 char msg[MsgSize]; int getAvaSize(char *p) { return MsgSize - int(p - msg); } msgBlock():next(-1),totalSize(0),size(0){} };
每个完整的消息都是由1个或连续数个msgBlock组成.这样就可以实现在消息队列中传递
变长的消息包.
消息队列的接口如下:
struct wPos { int blk; char *pos; wPos():blk(-1),pos(NULL){} }; template<int MsgSize = 1024,int QueueSize = 4096> //MsgSize,每个block的大小,QueueSize,最大消息数 class MsgQueue { public: template<typename T> int WriteNum(const T val); template<typename T> int ReWriteNum(wPos *pos,const T val); int WriteString(char *str); int WriteBin(void *bin,int len); wPos getWPos(); /* * brief: 向队列提交一个完整的消息 */ void MsgPush(); /* * brief : 读出一条完整的消息 */ int MsgPop(void *buf); //返回队列中第一个msg的大小 int GetFirstMsgSize(); };
为了减少内存的考贝,可以通过write函数簇直接向消息队列中写入数值型,string,和二进制数据.
当所有的数据都写完后,调用MsgPush将把这个消息包提交到队列中.
通过MsgPop可以获取一个完成的消息.还提供了rewrite接口,以修改已经写入队列的数值型数据.
以下是完整的程序:
#ifndef _MSGQUEUE_H #define _MSGQUEUE_H #include <assert.h> /* * brief : 消息队列,作为线程/进程间通信的消息队列,实现单读单写,无需加锁. * 对于进程间通信,使用共享内存实现. * */ template<int MsgSize> struct msgBlock { int next; int totalSize;//整个消息的大小,仅对消息中的第一个块有效 int size;//本块有效数据大小 char msg[MsgSize]; int getAvaSize(char *p) { return MsgSize - int(p - msg); } msgBlock():next(-1),totalSize(0),size(0){} }; struct wPos { int blk; char *pos; wPos():blk(-1),pos(NULL){} }; template<int MsgSize = 1024,int QueueSize = 4096> class MsgQueue { public: MsgQueue():idx_read(0),idx_write(0),curblk(0),pCurWrite(msgQueue[0].msg),saveTotalSize(0){} template<typename T> int WriteNum(const T val) { return Write(&val,(int)sizeof(T)); } template<typename T> int ReWriteNum(wPos *pos,const T val) { return ReWrite(pos,&val,(int)sizeof(T)); } int WriteString(char *str) { return Write(str,(int)strlen(str)+1); } int WriteBin(void *bin,int len) { return Write(bin,len); } wPos getWPos() { wPos ret; if((curblk + 1)%QueueSize == idx_read) return ret; ret.blk = curblk; ret.pos = pCurWrite; return ret; } /* * brief: 一条完整的消息已经完成写入队列 */ void MsgPush() { if((idx_write+1)%QueueSize == idx_read) return; msgQueue[idx_write].totalSize = saveTotalSize; msgQueue[curblk].next = -1; idx_write = (curblk+1)%QueueSize; pCurWrite = msgQueue[idx_write].msg; curblk = idx_write; saveTotalSize = msgQueue[idx_write].size = 0; msgQueue[idx_write].next = -1; } /* * brief : 读出一条完整的消息 */ int MsgPop(void *buf) { assert(buf); if(idx_read == idx_write) return 0; int tmp_cur = idx_read; char *pWrite = (char*)buf; int totalSize = msgQueue[tmp_cur].totalSize; for( ; ; ) { msgBlock<MsgSize> &curBlock = msgQueue[tmp_cur]; memcpy(pWrite,curBlock.msg,curBlock.size); pWrite += curBlock.size; tmp_cur = (tmp_cur+1)%QueueSize; if(curBlock.next == -1) break; } idx_read = tmp_cur; return totalSize; } //返回队列中第一个msg的大小 int GetFirstMsgSize() { if(idx_read == idx_write) return 0; return msgQueue[idx_read].totalSize; } private: int ReWrite(wPos *pos,const void *buf,int size) { assert(buf); assert(size>0); int tSize = size; msgBlock<MsgSize> *msgBlk = &msgQueue[pos->blk]; char *pRead = (char *)buf; while(tSize) { int avaSize = msgBlk->getAvaSize(pos->pos); //当前block空间已经用完,需要使用第二个block的空间 if(avaSize == 0) { pos->blk = (pos->blk + 1) % QueueSize; msgBlk = &msgQueue[pos->blk]; avaSize = MsgSize; pos->pos = msgBlk->msg; } int writesize = avaSize > size ? size : avaSize; memcpy(pos->pos,pRead,writesize); pos->pos += writesize; pRead += writesize; tSize -= writesize; } return size; } /* * brief: 向队列中写入数据,这些数据只是消息中的一部分,当所有数据都写完,调用MsgWrite. */ int Write(const void *buf,int size) { assert(buf); assert(size>0); //已经没有空间可供写入 if((curblk + 1)%QueueSize == idx_read) return 0; int tSize = size; msgBlock<MsgSize> *msgBlk = &msgQueue[curblk]; char *pRead = (char *)buf; while(tSize) { int avaSize = msgBlk->getAvaSize(pCurWrite); //当前block空间已经用完,需要使用第二个block的空间 if(avaSize == 0) { int next = (curblk + 1) % QueueSize; if(next == idx_read)//空间用完了 { curblk = idx_write; pCurWrite = msgQueue[idx_write].msg; saveTotalSize = 0; return 0; } msgBlk->next = curblk = next; msgBlk = &msgQueue[curblk]; avaSize = MsgSize; msgBlk->size = 0; pCurWrite = msgBlk->msg; } int writesize = avaSize > size ? size : avaSize; memcpy(pCurWrite,pRead,writesize); pCurWrite += writesize; pRead += writesize; saveTotalSize += writesize; msgBlk->size += writesize; tSize -= writesize; } return size; } private: int idx_read;//读下标 int idx_write;//写下标 char *pCurWrite;//当前写指针 int curblk;//当前写所在的块 int saveTotalSize; msgBlock<MsgSize> msgQueue[QueueSize]; };