Linux多執行緒消費者和生產者模型例項（互斥鎖和條件變數使用）

條件變數簡單介紹：

條件變數是執行緒可以使用的另一種同步機制。條件變數與互斥量一起使用的時候，允許執行緒以無競爭的方式等待特定的條件發生。
條件本身是由互斥量保護的。執行緒在改變條件變數狀態前必須先鎖住互斥量。
另一種是動態分配的條件變數，則用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);

執行緒同步機制參考部落格：linux多執行緒-----同步機制(互斥量、讀寫鎖、條件變數)

生產者和消費者模型：

消費者將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的時候，就要等待；

/*************************************************************************
    > File Name: cond_mutex.c
    > Author: 
    > Mail:  
    > Created Time: 2015年12月04日 星期五 17時44分38秒
 ************************************************************************/

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


#define CUSTOM_COUNT 2
#define PRODUCT_COUNT 3 

int nNum, nLoop;
int g_count = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_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[PRODUCT_COUNT];
	
	/*建立消費者執行緒*/
	for (i = 0; i < CUSTOM_COUNT; ++i){
		pthread_create(&tidCustom[i], NULL, consume, NULL);
	}

	sleep(3);

	/*建立生產者執行緒*/
	for (i = 0; i < PRODUCT_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 < PRODUCT_COUNT; ++i){
		pthread_join(tidProduce[i], NULL);
	}
	
	printf("parent exit\n");
	exit(0);
}

中間省去了一下值