生产者与消费者模式（线程的同步与互斥）

条件变量

条件变量的提出首先要涉及一个概念，就是生产者消费者模型：

生产者消费者，是在多线程同步的一个问题，两个固定大小缓冲区的线程，在实际运行是会发生问题，生产者是生成数据放入缓冲区，重复过程，消费者在缓冲区取走数据。

生产者消费者的模型提出了三种关系，两种角色，一个场所

三种关系： 
- 生产者之间的互斥关系 
- 消费者之间的竞互斥关系 
- 生产者和消费者之间互斥和同步关系（同一时刻只能有一个，要么在生产，要么在消费，这就是互斥关系，只能在生产者生产完了之后才能消费，这就是同步关系）

两个角色：一般是用进程或线程来承担生产者或消费者

一个场所：有效的内存区域。（如单链表，数组）
我们就可以把这个想象成生活中的超市供货商，超市，顾客的关系，超市供货商供货，超市是摆放货物的场所，然后用户就是消费的。
条件变量属于线程的一种同步的机制，条件变量与互斥锁一起使用，可以使得线程进行等待特定条件的发生。条件本身是由互斥量保护的，线程在改变条件状态之前首先会锁住互斥量。其他线程在获得互斥量之前不会察觉这种改变，因此互斥量锁定后才能计算条件。

和互斥锁一样，使用条件变量，同样首先进行初始化：

int pthread_cond_init(pthread_cond_t *restrict cond,              const pthread_condattr_t *restrict attr);pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
1
2
3
4
5
1
2
3
4
5

和互斥锁的初始化一样，它也可以采用init或者是直接利用宏进行初始化。

条件变量本身就是依赖互斥锁的，条件本身是由互斥量保护的，线程在改变条件状态钱先要锁住互斥量，它是利用线程间共享的全局变量进行同步的一种机制。

我们使用pthread_cond_wait进行等待条件变量变为真，如果在规定的时间不能满足，就会生成一个返回错误码的变量。

 int pthread_cond_wait(pthread_cond_t *restrict cond,              pthread_mutex_t *restrict mutex);
1
2
3
1
2
3

把锁传递给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);
1
2
3
1
2
3

这两个函数都是用来进行唤醒线程操作的，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 64sem_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;}