c语言实现多线程下的链表队列

项目中需要一个链表，线程A进行入队操作（生产者），线程B进行查询、出队操作（消费者），同时希望线程B在队列为空时阻塞，降低cpu负载，因此考虑用pthread_cond_wait进行实现：

主要实现功能：

1）出队和入队的加锁

2）当有元素入队时唤醒线程B

3）队列为空时线程B进入休眠

头文件：

#ifndef Queue_H
#define Queue_H
#include 
#include 
typedef char* Frame;
typedef struct node * PNode;
typedef struct node
{
	Frame frame;
	PNode next;
}Node;

typedef struct
{
	PNode front;
	PNode rear;
	int size;
	pthread_mutex_t q_lock;
	pthread_cond_t cond;
}Queue;

/*构造一个空队列*/
Queue *InitQueue();

/*销毁一个队列*/
void DestroyQueue(Queue *pqueue);

/*清空一个队列*/
void ClearQueue(Queue *pqueue);

/*判断队列是否为空*/
int IsEmpty(Queue *pqueue);

/*返回队列大小*/
int GetSize(Queue *pqueue);

/*返回队头元素*/
PNode GetFront(Queue *pqueue, Frame *frame);

/*返回队尾元素*/
PNode GetRear(Queue *pqueue, Frame *frame);

/*将新元素入队*/
PNode EnQueue(Queue *pqueue,Frame frame);

/*队头元素出队*/
PNode DeQueue(Queue *pqueue);

/*遍历队列并对各数据项调用visit函数*/
void QueueTraverse(Queue *pqueue,void (*visit)());

#endif

c文件：

#include"Queue.h"

/*构造一个空队列*/
Queue *InitQueue()
{
	Queue *pqueue = (Queue *)malloc(sizeof(Queue));
	if(pqueue!=NULL)
	{
		pqueue->front = NULL;
		pqueue->rear = NULL;
		pqueue->size = 0;
		pthread_mutex_init(&pqueue->q_lock, NULL);		
		pthread_cond_init(&pqueue->cond, NULL);
	}
	return pqueue;
}

/*销毁一个队列*/
void DestroyQueue(Queue *pqueue)
{
	if(!pqueue)
		return;
	ClearQueue(pqueue);
	pthread_mutex_destroy(&pqueue->q_lock);
	pthread_cond_destroy(&pqueue->cond);
	free(pqueue);
	pqueue = NULL;
}

/*清空一个队列*/
void ClearQueue(Queue *pqueue)
{
	while(!IsEmpty(pqueue)) {
		DeQueue(pqueue);
	}

}

/*判断队列是否为空*/
int IsEmpty(Queue *pqueue)
{
	if(pqueue->front==NULL&&pqueue->rear==NULL&&pqueue->size==0)
		return 1;
	else
		return 0;
}

/*返回队列大小*/
int GetSize(Queue *pqueue)
{
	return pqueue->size;
}

/*返回队头元素*/
PNode GetFront(Queue *pqueue, Frame *frame)
{
	pthread_mutex_lock(&pqueue->q_lock);
	/*
	if(!IsEmpty(pqueue))
	{
		*frame = pqueue->front->frame;
	}else {
		pthread_cond_wait(&pqueue->cond, &pqueue->q_lock);
	}*/
	while(IsEmpty(pqueue))
		pthread_cond_wait(&pqueue->cond, &pqueue->q_lock);
	*frame = pqueue->front->frame;
	pthread_mutex_unlock(&pqueue->q_lock);
	return pqueue->front;//---->此处有bug，队列为空时，在锁释放后，pqueue->front可能被入队操作赋值，出现frame等于NULL，而pqueue->front不等于NULL
}

/*返回队尾元素*/

PNode GetRear(Queue *pqueue, Frame *frame)
{
	if(!IsEmpty(pqueue)) {
		*frame = pqueue->rear->frame;
	}
	return pqueue->rear;
}

/*将新元素入队*/
PNode EnQueue(Queue *pqueue, Frame frame)
{
	PNode pnode = (PNode)malloc(sizeof(Node));
	if(pnode != NULL) {
		pnode->frame = frame;
		pnode->next = NULL;
		
		pthread_mutex_lock(&pqueue->q_lock);
		if(IsEmpty(pqueue)) {
			pqueue->front = pnode;
		} else {
			pqueue->rear->next = pnode;
		}
		pqueue->rear = pnode;
		pqueue->size++;
		pthread_cond_signal(&pqueue->cond);
		pthread_mutex_unlock(&pqueue->q_lock);
	}
	return pnode;
}

/*队头元素出队*/
PNode DeQueue(Queue *pqueue)
{
	PNode pnode = pqueue->front;
	pthread_mutex_lock(&pqueue->q_lock);
	if(!IsEmpty(pqueue)) {
		pqueue->size--;
		pqueue->front = pnode->next;
		free(pnode);
		if(pqueue->size==0)
			pqueue->rear = NULL;
	}
	pthread_mutex_unlock(&pqueue->q_lock);
	return pqueue->front;
}

/*遍历队列并对各数据项调用visit函数*/
void QueueTraverse(Queue *pqueue, void (*visit)())
{
	PNode pnode = pqueue->front;
	int i = pqueue->size;
	while(i--)
	{
		visit(pnode->frame);
		pnode = pnode->next;
	}
		
}