生产者-消费者模型的两种实现方式

https://www.cnblogs.com/caolicangzhu/p/7086176.html

本文主要来总结生产者-消费者模型的代码实现,至于其原理,请大家自行百度.

一、基于链表的生产-消费模型(条件变量)

　　我们以链表为例,生产者进行头部插入,消费者进行头部删除,因此,先将链表相关操作封装为LinkList.h,具体代码如下:

//文件说明:LinkList.h
//作者:高小调
//创建时间:2017年06月27日 星期二 14时57分27秒
//开发环境:Kali Linux/g++ v6.3.0
#include<assert.h>
#include<stdlib.h>
#include<stdio.h>
//链表节点
typedef struct LinkListNode{
    int val;
    struct inkListNode *next;
}Node,*pNode,**ppNode;
//初始化链表
void InitLinkList(ppNode head){
    assert(head);
    *head = NULL;
}
//判断链表是否为空
int IsEmpty(pNode head){
    return head==NULL;
}
//申请新节点
pNode BuyNewNode(int val){
    pNode ret = (pNode)malloc(sizeof(Node));
    ret->val = val;
    ret->next = NULL;
    return ret;
}
//头插
void PushFront(ppNode head,int val){
    assert(head);
    if(*head==NULL){
        *head = BuyNewNode(val);
        return ;
    }
    pNode newNode = BuyNewNode(val);
    newNode->next = *head;
    *head = newNode;
}
//头删
void PopFront(ppNode head,int *val){
    assert(head);
    if((*head) == NULL){
        return ;
    }
    if((*head)->next == NULL){
        *val = (*head)->val;
        free(*head);
        *head = NULL;
        return ;
    }
    pNode del = *head;
    *head = del->next;
    *val = del->val;
    free(del);
}
//销毁链表
void Destory(ppNode head){
    assert(head);
    pNode cur = *head;
    pNode del = NULL;
    while(cur!=NULL){
        del = cur;
        cur = cur->next;
        free(del);
    }
    *head = NULL;
}
//打印链表
void PrintLinkList(pNode head){
    pNode cur = head;
    while(cur!=NULL){
        printf("%d ",cur->val);
        cur = cur->next;
    }
    printf("\n");
}

　　然后进入我们线程的生产消费模型:

//文件说明:test.c
//作者:高小调
//创建时间:2017年06月27日 星期二 14时56分13秒
//开发环境:Kali Linux/g++ v6.3.0
#include<stdio.h>
#include<pthread.h>
#include"LinkList.h"
//互斥锁
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
//条件变量
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
//测试链表
void TestLinkList(){
    pNode head;
    InitLinkList(&head);
    int tmp;
    for(int i=0; i<10; ++i){
        PushFront(&head,i);
        PrintLinkList(head);
    }
    for(int i=0; i<10; ++i){
        PopFront(&head,&tmp);
        PrintLinkList(head);
    }
}
pNode head;
//生产者:每次向头节点插入数据
void *Productor(void*arg){
    int val = 0;
    while(1){
        //互斥锁加锁:确保生产时不会消费,消费时不会生产
        pthread_mutex_lock(&lock);
        val = rand()%100;
        PushFront(&head,val);
        printf("Productor push %d\n",val);
        //互斥锁解锁
        pthread_mutex_unlock(&lock);
        //条件变量,生产完成之后向消费者发出信号消费
        pthread_cond_signal(&cond);
        sleep(1);
    }
}
//消费者:每次将头节点数据取出
void *Consumer(void*arg){
    int val = 0;
    while(1){
        //互斥锁
        pthread_mutex_lock(&lock);
        while(head==NULL){
            //链表中没数据,阻塞等待生产者发消费信号
            printf("wait for data\n");
            pthread_cond_wait(&cond,&lock);
        }
        PopFront(&head,&val);
        printf("Consumer pop %d\n",val);
        pthread_mutex_unlock(&lock);
        sleep(1);
    }
}
int main(){
    InitLinkList(&head);
    pthread_t cid1,cid2;
    pthread_create(&cid1,NULL,Productor,NULL);
    pthread_create(&cid2,NULL,Consumer,NULL);
    pthread_join(&cid1,NULL);
    pthread_join(&cid2,NULL);
     
    return 0;
}

二、基于环形队列的生产-消费模型(信号量)

//文件说明:test2.c
//作者:高小调
//创建时间:2017年06月27日 星期二 16时29分30秒
//开发环境:Kali Linux/g++ v6.3.0
#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
#include<stdlib.h>
#define SIZE 1024
//环形队列
int arr[SIZE] = {0};
sem_t sem_pro;      //描述环形队列中的空位置
sem_t sem_con;      //描述唤醒队列中的数据
//生产者，只要环形队列有空位,便不断生产
void*productor(void*arg){
    int data = 0;
    int proIndex = 0;
    while(1){
        //有空位便生产,没空位便阻塞等消费者消费
        sem_wait(&sem_pro);
        data = rand()%1234;
        arr[proIndex] = data;
        printf("product done %d\n",data);
        proIndex = (proIndex+1)%SIZE;
        //供消费者消费的数据加1
        sem_post(&sem_con);
    }
}
//消费者,只要环形队列中有数据,就不断消费
void*consumer(void*arg){
    int data = 0;
    int conIndex = 0;
    while(1){
        //环形队列中存在数据则消费,不存在数据则阻塞,直到有数据为止
        sem_wait(&sem_con);
        data = arr[conIndex];
        printf("consume done %d\n",data);
        conIndex = (conIndex+1)%SIZE;
        //最后,消费了一个数据,空位加1
        sem_post(&sem_pro);
    }
}
int main(){
    pthread_t pro,con;
    sem_init(&sem_pro,0,SIZE-1);        //一开始有很多空位置
    sem_init(&sem_con,0,0);         //但并没有数据
    pthread_create(&pro,NULL,productor,NULL);
    pthread_create(&con,NULL,consumer,NULL);
    pthread_join(pro,NULL);
    pthread_join(con,NULL);
    sem_destroy(&sem_pro);
    sem_destroy(&sem_con);
    return 0;
}