对几种队列的总结

队列1：
描述：此队列为链表形式，由于为链表，所以没有设置最大值，可以无限往后增加，直到内存使用完
typedef struct PacketList
{
byte *pkt;
int pkt_size;
PacketList *next;
}PacketList;


typedef 
struct PacketQueue 
{
  
PacketList *first_pkt, *last_pkt;
  
int nb_packets;
  
int size;
  
HANDLE mutex;
  
HANDLE cond;


}PacketQueue;






PacketQueue videoq;




int quit=0;
void packet_queue_init(PacketQueue *q) 
{
  
memset(q, 0, sizeof(PacketQueue));
  
q->mutex = CreateMutex(NULL,false,NULL);
  
//q->cond = CreateSemaphore(NULL,1,1,NULL);
q->cond=CreateEvent(NULL,false,false,NULL);//此处用事件比用信号量更好
}


int packet_queue_put(PacketQueue *q, byte *pkt,int pkt_size) 
{


  
PacketList *pkt1;
  
if(!pkt) {
    return -1;
  }
  
pkt1 = (PacketList*)malloc(sizeof(PacketList));
  
if (!pkt1)
    return -1;
  
pkt1->pkt=(byte *)malloc(pkt_size);
  
if(!pkt1->pkt)
  {
 free(pkt1);
 return -1;
  }
  
memcpy(pkt1->pkt,pkt,pkt_size);
  
pkt1->pkt_size=pkt_size;
  
pkt1->next = NULL;
  
  
  

WaitForSingleObject(q->mutex,INFINITE);
  
  
if (!q->last_pkt)
    q->first_pkt = pkt1;
  
else
    q->last_pkt->next = pkt1;
  
q->last_pkt = pkt1;
  
q->nb_packets++;
  
q->size += pkt1->pkt_size;
  
//ReleaseSemaphore(q->cond,1,NULL);
  ResetEvent(q->cond);
  
ReleaseMutex(q->mutex);
  
return 0;


}


static int packet_queue_get(PacketQueue *q, byte *pkt, int block)//pkt由外部来分配内存，要足够大才行
{
  
PacketList *pkt1;
  
int ret;
  
  
WaitForSingleObject(q->mutex,INFINITE);
  
  
for(;;) 
{
    
    
if(quit) {
      ret = -1;
      break;
    }



pkt1 = q->first_pkt;

if (pkt1) 
{

q->first_pkt = pkt1->next;

if (!q->first_pkt)
        q->last_pkt = NULL;

q->nb_packets--;

q->size -= pkt1->pkt_size;


memcpy(pkt,pkt1->pkt,pkt1->pkt_size);

free(pkt1->pkt);

free(pkt1);

ret = 1;

break;
    
} else if (!block) 
{//为0 不阻塞，为1阻塞
      
ret = 0;
      
break;
    
} else 
{

ReleaseMutex(q->mutex);

WaitForSingleObject(q->cond,INFINITE);

WaitForSingleObject(q->mutex,INFINITE);
    
}
  
}
  
ReleaseMutex(q->mutex);
  
return ret;


}


队列2：
描述：此队列有最大值，存储数据的地方为申请的一段内存区。
typedef struct _NewQueue
{
HANDLE hMutex;//互斥量事件
HANDLE hConread;//信号量
HANDLE hConwrite;//信号量
unsigned char * buf;//数据缓冲区
int bufsize;//数据缓冲区大小
int write_ptr;//写入位置
int read_ptr;//读取位置


}NewQueue;
void init_queue(NewQueue *que, int size)
{
que->hMutex=CreateMutex(NULL,false,NULL);//每个队列的互斥量事件
que->hConread=CreateSemaphore(NULL,1,1,NULL);
que->hConwrite=CreateSemaphore(NULL,1,1,NULL);
que->buf=new unsigned char[size];//给队列分配内存
que->bufsize = size;
que->read_ptr = que->write_ptr = 0;//将队列的初始读取和写入位置都变为0
}


void free_queue(NewQueue* que) 
{
WaitForSingleObject(que->hMutex,INFINITE)

if(que->buf!=NULL)
{
delete[] que->buf;
que->buf=NULL;
}
que->bufsize = 0;
que->read_ptr = que->write_ptr = 0;
ReleaseMutex(que->hMutex);
}
int put_queue(NewQueue*que, uint8_t* buf, int size，int block) 
{
int ret;
WaitForSingleObject(que->hMutex,INFINITE)
for(;;)
{
if(que->buf==NULL)
{
ret =-1;
goto end;
}

if(que->write_ptr>=que->read_ptr)
{
int nEmptyBufSize=que->bufsize-que->write_ptr+que->read_ptr;
if(nEmptyBufSize>=size)
{
int tmp_size=que->bufsize-que->write_ptr;//队列后面剩余的大小
if(size<=tmp_size)
{
memcpy(que->buf+que->write_ptr,buf,size);

}
else
{
memcpy(que->buf+que->write_ptr,buf,tmp_size);
memcpy(que->buf,buf+tmp_size,size-tmp_size);

}
que->write_ptr=(que->write_ptr+size)%que->bufsize;
ReleaseSemaphore(que->hConread,1,NULL);
ret=1;
goto end;
}
//写入内存不够
else if(!block)
{
ret=0;
goto end;
}
else
{
ReleaseMutex(que->hMutex);
WaitForSingleObject(que->hConwrite,INFINITE);
WaitForSingleObject(que->hMutex,INFINITE);
}
}
else
{
int nEmptyBufSize=que->read_ptr-que->write_ptr;
if(nEmptyBufSize>=size)
{
memcpy(que->buf+que->write_ptr,buf,size);
que->write_ptr=(que->write_ptr+size)%que->bufsize;
ReleaseSemaphore(que->hConread,1,NULL);
ret=1;
goto end;
}
//写入内存不够
else if(!block)
{
ret=0;
goto end;
}
else
{
ReleaseMutex(que->hMutex);
WaitForSingleObject(que->hConwrite,INFINITE);
WaitForSingleObject(que->hMutex,INFINITE);
}
}
}

end: ReleaseMutex(que->hMutex);
return ret;
}
int get_queue(NewQueue*que, uint8_t* buf, int size，int block) 
{
int ret;
WaitForSingleObject(que->hMutex,INFINITE)
for(;;)
{
if(que->buf==NULL)
{
ret=-1;
goto end;
}
if(que->read_ptr<=que->write_ptr)
{
int nEmptyBufferSize=que->write_ptr-que->read_ptr;
if(nEmptyBufferSize>=size)
{
memcpy(buf,que->buf+que->read_ptr,size);
que->read_ptr=(que->read_ptr+size)%que->bufsize;
ReleaseSemaphore(que->hConwrite,1,NULL);
ret=1;
goto end;
}
else if(!block)
{
ret=0;
goto end;
}
else
{
ReleaseMutex(que->hMutex);
WaitForSingleObject(que->hConread,INFINITE);
WaitForSingleObject(que->hMutex,INFINITE);
}

}
else
{
int nEmptyBufferSize=que->bufsize-que->read_ptr+que->write_ptr;
if(nEmptyBufferSize>=size)
{
int tmp_size=que->bufsize-que->read_ptr;
if(size<=tmp_size)
{
memcpy(buf,que->buf+que->read_ptr,size);
}
else
{
memcpy(buf,que->buf+que->read_ptr,tmp_size);
memcpy(buf+tmp_size,que->buf,size-tmp_size);
}
que->read_ptr=(que->read_ptr+size)%que->bufsize;
ReleaseSemaphore(que->hConwrite,1,NULL);
ret=1;
goto end;
}
else if(!block)
{
ret=0;
goto end;
}
else
{
ReleaseMutex(que->hMutex);
WaitForSingleObject(que->hConread,INFINITE);
WaitForSingleObject(que->hMutex,INFINITE);
}
}
}//for
end: ReleaseMutex(que->hMutex);
return ret;
}


队列3：
原来主控里面的形式，也是最简单的方式，用一个大的二维数组，记录数据，然后用还有一个长度数据数组 ，写入和读取的位置，控制好不要让读取的位置到写入的位置前面去就好了。




//入队列操作
int enqueue(SOAP_SOCKET sock)
{
  int status = SOAP_OK;
  int next;
  pthread_mutex_lock(&queue_cs);
  next = tail +1;
  if (next >= MAX_QUEUE) 
    next = 0;
  if (next == head) 
      status = SOAP_EOM;
  else
  {
    queue[tail] =sock;
    tail = next;
  }
  pthread_cond_signal(&queue_cv);
  pthread_mutex_unlock(&queue_cs);
  return status;
}


//出队列操作
SOAP_SOCKET dequeue()
{
  SOAP_SOCKET sock;
  pthread_mutex_lock(&queue_cs);
   while (head == tail )
   {
          pthread_cond_wait(&queue_cv,&queue_cs);
   }
  sock = queue[head++];
  if (head >= MAX_QUEUE)
        {
    head =0;
  }
  pthread_mutex_unlock(&queue_cs);
  return sock;
}