互斥锁和条件变量使用实例

条件变量简介：

条件变量是线程中的东西，就是等待某一条件的发生，和信号一样。

用法
条件变量使我们可以睡眠等待某种条件出现。
条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待"条件变量的条件成立"而挂起；另一个线程使"条件成立"（给出条件成立信号）。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。
条件变量类型为 pthread_cond_t。
条件变量与互斥量一起使用的时候，允许线程以无竞争的方式等待特定的条件发生。
条件本身是由互斥量保护的。线程在改变条件变量状态前必须先锁住互斥量。

另一种是动态分配的条件变量，则用pthread_cond_init函数进行初始化。

在释放底层的内存空间之前，可以使用pthread_cond_destroy对条件变量进行去初始化。

条件变量在使用前必须初始化，一种是静态初始化：pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;  
  
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);  
int pthread_cond_destroy(pthread_cond_t *cond);  
  
int pthread_cond_signal(pthread_cond_t *cond);//唤醒等待该条件变量上的某个线程  
int pthread_cond_broadcast(pthread_cond_t *cond);//唤醒等待该条件变量上的所有线程  
  
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);  
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);  

生产者和消费者模型：

消费者将g_count每次减去1，生产者将g_count每次加1；消费者会判断g_count的大小，如果g_count==0那么消费者线程要阻塞；但是它还会一直占有锁，所以这样就阻止了其它线程对g_count的操作；此时我们要用到条件变量；调用pthread_cond_wait(&g_cond, &g_mutex);让互斥锁g_mutex在这个g_cond条件上等待；

线程调用pthread_cond_wait这个函数之后，内核会做下面这些事：
1，拿到锁的线程，把锁暂时释放；
2，线程休眠，进行等待；
3，线程等待通知，要醒来。（重新获取锁）
线程库将上面三步做成了原子性操作；和Linux内核绑定在一起；

在生产者线程中当对g_count++之后（也就是生产了产品），会调用pthread_cond_signal(&g_cond);向这个条件变量g_cond上发送一个信号,表示条件满足；
如果条件满足，那么刚才因为调用pthread_cond_wait而等待的消费者线程会醒来（重新获取锁，再次判断条件是否满足）;如果g_count>0,然后在临界区进行操作，最后解锁，离开临界区；

因为涉及到多个线程对全局变量g_count进行操作，所以要用线程互斥锁对g_count进行控制；所以首先定义互斥锁mutex，然后调用pthread_mutex_lock(&mutex)进行上锁，对g_count进行操作之后再调用pthread_mutex_unlock(&mutex)进行解锁；

我们还希望对g_count的最大值进行控制，比如希望它的最大值是10；那么当g_count等于10的时候，就要等待；

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>

#define custom_count 2
#define produce_count 3

int nNum, nLoop;
int g_count = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_MUTEX_INITIALIZER;

void *consume(void *arg)
{
	while (1)
	{
		pthread_mutex_lock(&mutex);
		while (g_count == 0)
		{
			printf("consume is waiting: %lu\n", pthread_self());
			pthread_cond_wait(&cond, &mutex);
		}
		printf("consume is %lu, g_count is %d\n", pthread_self(), g_count);
		g_count--;
		pthread_mutex_unlock(&mutex);
		sleep(1);
	}
	pthread_exit(NULL);
}

void *produce(void *arg)
{
	while (1)
	{
		pthread_mutex_lock(&mutex);
		if (g_count >= 10)
		{
			printf("产品太多了，需要休眠1秒\n");
			pthread_mutex_unlock(&mutex);
			sleep(1);
			continue;
		}
		//不需要解锁再上锁，大于10，会解锁，会continue，不会执行下面语句
		printf("start produce the product\n");
		g_count++;
		printf("produce is %lu, g_count is %d\n", pthread_self(), g_count);
		pthread_cond_signal(&cond);
		pthread_mutex_unlock(&mutex);
		sleep(1);
	}
	pthread_exit(NULL);
}

int main()
{
	int i = 0;
	pthread_t tidCustom[custom_count];
	pthread_t tidProduce[produce_count];

	//创建消费者线程
	for (i = 0; i < custom_count; i++)
	{
		pthread_create(&tidCustom[i], NULL, consume, NULL);
	}
	sleep(3);
	//创建生产者线程
	for (i = 0; i < produce_count; i++)
	{
		pthread_create(&tidProduce[i], NULL, produce, NULL);
	}
	
	//等待消费者线程
	for (i = 0; i < custom_count; i++)
	{
		pthread_join(tidCustom[i], NULL);
	}

	//等待生产者线程
	for (i = 0; i < produce_count; i++)
	{
		pthread_join(tidProduce[i], NULL);
	}
	printf("parent exit\n");
	exit(0);
}

中间省略一部分