代码如下

#include 

#include 

#include 



struct msg {

	struct msg *next;

	int num;

};



struct msg *head;

pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;



void *consumer(void *p)

{

	struct msg *mp;



	for (;;) {

		pthread_mutex_lock(&lock);

		while (head == NULL)

			pthread_cond_wait(&has_product, &lock);

		mp = head;

		head = mp->next;

		pthread_mutex_unlock(&lock);

		printf("Consume %dn", mp->num);

		free(mp);

		sleep(rand() % 5);

	}

}



void *producer(void *p)

{

	struct msg *mp;

	for (;;) {

		mp = malloc(sizeof(struct msg));

		mp->num = rand() % 1000 + 1;

		printf("Produce %dn", mp->num);

		pthread_mutex_lock(&lock);

		mp->next = head;

		head = mp;

		pthread_mutex_unlock(&lock);

		pthread_cond_signal(&has_product);

		sleep(rand() % 5);

	}

}



int main(int argc, char *argv[]) 

{

	pthread_t pid, cid;  



	srand(time(NULL));

	pthread_create(&pid, NULL, producer, NULL);

	pthread_create(&cid, NULL, consumer, NULL);

	pthread_join(pid, NULL);

	pthread_join(cid, NULL);

	return 0;

}

我也是觉得没有区别

有区别的！！！
为什么要使用while循环来判断条件，是因为可能有“惊群效应”。

引用下POSIX的RATIONALE： 

Condition Wait Semantics 

It is important to note that when pthread_cond_wait() and pthread_cond_timedwait() return without error, the associated predicate may still be false. Similarly, when pthread_cond_timedwait() returns with the timeout error, the associated predicate may be true due to an unavoidable race between the expiration of the timeout and the predicate state change. 

The application needs to recheck the predicate on any return because it cannot be sure there is another thread waiting on the thread to handle the signal, and if there is not then the signal is lost. The burden is on the application to check the predicate. 

Some implementations, particularly on a multi-processor, may sometimes cause multiple threads to wake up when the condition variable is signaled simultaneously on different processors. 

In general, whenever a condition wait returns, the thread has to re-evaluate the predicate associated with the condition wait to determine whether it can safely proceed, should wait again, or should declare a timeout. A return from the wait does not imply that the associated predicate is either true or false. 

It is thus recommended that a condition wait be enclosed in the equivalent of a "while loop" that checks the predicate. 

从上文可以看出： 
1，pthread_cond_signal在多处理器上可能同时唤醒多个线程，当你只能让一个线程处理某个任务时，其它被唤醒的线程就需要继续 wait,while循环的意义就体现在这里了，而且规范要求pthread_cond_signal至少唤醒一个pthread_cond_wait上的线程，其实有些实现为了简单在单处理器上也会唤醒多个线程. 
2，某些应用，如线程池，pthread_cond_broadcast唤醒全部线程，但我们通常只需要一部分线程去做执行任务，所以其它的线程需要继续wait.所以强烈推荐此处使用while循环. 
   其实说白了很简单，就是pthread_cond_signal()也可能唤醒多个线程，而如果你同时只允许一个线程访问的话，就必须要使用while来进行条件判断，以保证临界区内只有一个线程在处理。

大多数的并发编程书籍都会强调要使用while.但是，要理解：对于2个线程，1个生产，1个消费。没有必要用while的。

问题在于，如果存在多个生产者或多个消费者。必须采用while结构。

对比while和if. while预期在pthread_cond_wait()返回后，仍然有可能再次调用pthread_cond_wait()，只要head==NULL.

而，if预期，从pthread_cond_wait()返回后，就直接继续了。

查看while，在什么时候pthread_cond_wait()还会再次被调用，那就是有另一个线程，将head置成了NULL。这一点，在2线程不会发生，但3个线程就有可能。

总的来说，记住用while，你就不会错。