条件变量的提出首先要涉及一个概念，就是生产者消费者模型：
和互斥锁一样，使用条件变量，同样首先进行初始化：
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
和互斥锁的初始化一样，它也可以采用init或者是直接利用宏进行初始化。
条件变量本身就是依赖互斥锁的，条件本身是由互斥量保护的，线程在改变条件状态钱先要锁住互斥量，它是利用线程间共享的全局变量进行同步的一种机制。
我们使用pthread_cond_wait进行等待条件变量变为真，如果在规定的时间不能满足，就会生成一个返回错误码的变量。
int pthread_cond_wait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex);
把锁传递给wait函数，函数自动把等待条件的线程挂起，放入消费者等待队列，然后解锁挂起线程所占有的互斥锁，这个时候就可以去跑其他线程，然后当等待条件满足的时候，这个时候从等待队列中出来执行，获得刚才自己所占有的锁。
一个线程可以调用pthread_cond_wait在一个Condition Variable上阻塞等待,这个函数做以下三步操作:
1. 释放Mutex
2. 阻塞等待
3. 当被唤醒时,重新获得Mutex并返回
满足条件的时候可以使用函数pthread_cond_signal进行唤醒
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);
这两个函数都是用来进行唤醒线程操作的，signal一次从消费者队列中至少唤醒一个线程，broad_cast能唤醒等待该条件的所有线程。
当然和mutex类似，条件变量也需要清除。
int pthread_cond_destroy(pthread_cond_t *cond);
#include<stdio.h>
#include<assert.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
typedef struct Node
{
struct Node *next;
int val;
}Node;
void list_init(Node **phead)
{
assert(phead);
Node *temp = (Node*)malloc(sizeof(Node));
temp->next = NULL;
temp->val = 0;
*phead = temp;
}
void list_push(Node *phead,int _data) //头插
{
assert(phead);
Node *pM = (Node*)malloc(sizeof(Node));
if (pM)
{
pM->val = _data;
pM->next = phead->next;
phead->next = pM;
}
}
int empty(Node *phead)
{
return (phead->next == NULL ? 1: 0);
}
void list_print(Node *phead)
{
assert(phead);
if (empty(phead))
return ;
Node *pCur = phead->next;
while (pCur)
{
printf("%d->",pCur->val);
pCur = pCur->next;
}
printf("%s\n","NULL");
}
void list_pop(Node *phead,int *data) //头删
{
assert(phead);
if (empty(phead))
return ;
Node *ptemp = phead->next;
phead->next = ptemp->next;
*data = ptemp->val;
free(ptemp);
ptemp = NULL;
}
void list_destroy(Node *phead)
{
assert(phead);
while (!empty(phead))
{
int data;
list_pop(phead,&data);
}
}
//生产者线程
void* producer(void *arg)
{
Node *phead = (Node *)arg;
while (1)
{
pthread_mutex_lock(&mutex); //申请互斥锁
int data = rand()%100;
list_push(phead,data);
pthread_mutex_unlock(&mutex);//释放互斥锁
printf("prodecer sucess %d\n",data);
pthread_cond_signal(&cond); //以单播的方式通知拥有条件变量的另外一个线程，告诉消费者，生产者生产好了，可以消费了。
sleep(1);
}
return NULL;
}
//消费者线程
void* consumer(void *arg)
{
Node *phead = (Node *)arg;
while (1)
{
int data;
pthread_mutex_lock(&mutex);
if (empty(phead)) //如果没有资源可以消费了，则等待
{
pthread_cond_wait(&cond,&mutex); //这个函数调用一定是在拥有互斥锁的前提下.这个函数做三件事，第一：释放互斥锁，二，阻塞等待，三，唤醒的时候重新获得互斥锁。
}
list_pop(phead,&data);//有资源就消费
pthread_mutex_unlock(&mutex);
printf("consumer sucess %d\n",data);
}
return NULL;
}
int main()
{
Node *phead;
list_init(&phead);
pthread_t id1;
pthread_t id2;
pthread_create(&id1,NULL,producer,(void*)phead);
pthread_create(&id2,NULL,consumer,(void*)phead);
pthread_join(id1,NULL);
pthread_join(id2,NULL);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
return 0;
}
信号量相关函数：
信号量(Semaphore)和Mutex类似,表示可用资源的数量,和Mutex不同的是这个数量可以大于1
#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value); sem_init() 初始化一个定位在 sem 的匿名信号量。value 参数指定信号量的初始值。 pshared 参数指明信号量是由进程内线程共享，还是由进程之间共享。如果 pshared 的值为 0，那么信号量将被进程内的线程共享，并且应该放置在所有线程都可见的地址上(如全局变量，或者堆上动态分配的变量)。如果 pshared 是非零值，那么信号量将在进程之间共享
int sem_destroy(sem_t *sem);
int sem_wait(sem_t *sem);//类似P操作
int sem_trywait(sem_t *sem);
int sem_post(sem_t *sem);//类似V操作
#include<stdio.h>
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<semaphore.h>
//二个规则，（1）消费者一定要等到生产才能消费，（2）生产者如果生产的快的话，不能套消费者一个圈
#define SIZE 64
sem_t blanks; //二个信号量
sem_t datas;
int buf[SIZE]; //用数组模拟一个环形队列。
void *productor(void *arg)
{
int i = 0; //i = 0表示生产的起始位置。
while (1)
{
// pthread_mutex_lock(&mutex_p);
sem_wait (&blanks);//生产者在生产之前要有格子资源。
int data = rand()%1234;
buf[i] = data;
printf("productor done...data:%d\n",data);
i++;
i%=SIZE;//i++总有超过数组的长度的时候，为了模拟环形队列，所以求模。
sleep(1); //生产的慢点
sem_post(&datas);//生产者生产完了，数据资源就多了一个。
// pthread_mutex_unlock(&mutex_p);
}
return NULL;
}
void *consummer(void *arg)
{
int i = 0;
while (1)
{
sem_wait(&datas); //消费者在消费之前要有消费资源。
int data = buf[i];
printf("consummer done...data:%d\n",data);
i++;
i%= SIZE;
sem_post(&blanks);//消费者消费完了格子资源就多了一个。
}
return NULL;
}
int main()
{
sem_init(&blanks,0,SIZE);
sem_init(&datas,0,0); //信号量的初始化要在多线程之前
pthread_t id1,id2;
pthread_create(&id1,NULL,productor,NULL);
pthread_create(&id2,NULL,consummer,NULL);
pthread_join(id1,NULL);
pthread_join(id2,NULL);
sem_destroy(&blanks);
sem_destroy(&datas);
return 0;
}