Linux 下多线程的消费者-生产者模型

时间：2022-08-02 15:14:12

消费者-生产者模型

    所谓这个模型指在ipc时，由扮演的生产者进程产生数据，由扮演消费者的进程去拿走数据。
    这个模型 是由3种关系俩种角色一个场景所描述而成。
    三种关系指：
    消费者-消费者  --->  互斥
    生产者-生产者  --->  互斥
    消费者-生产者  --->  同步与互斥
    俩种角色指：
    消费者与生产者
     一个场景：
     临界区：多个进程看到的同一份临界资源。
单消费-单产生模型代码

    基于链表实现（应用了互斥锁和条件变量） 
#ifndef CON_PROC_H
#define CON_PROC_H 
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
typedef int datatype;
typedef struct list{
   int _value;
   struct list * _pNext;
} Node,*PNode,**position;
PNode head;
void Insert(datatype value,position p)
{
    PNode NewNode=(Node*)malloc(sizeof(Node));
    if(NewNode==NULL)
   {   
      perror("malloc");
      return ;
   }   
   if(*p==NULL)
   {   
     NewNode->_value=value;
     NewNode->_pNext=NULL; 
     *p=NewNode;
     return ;
   }   
   NewNode->_value=value;
   NewNode->_pNext=*p;
   *p=NewNode;
}
int  empty()
{
   return head==NULL;
}
void pop_front(int*p)
{
   if(empty())
    {   
     printf("List is empty\n");
      return ;
    }
   PNode del=head;
   *p=head->_value;
   head=head->_pNext;
   free(del);
}
void Delete_List()
{
   PNode del;
   while(head)
   {
     del=head;
     head=head->_pNext;
     free(del);
   }
}
#endif
#include "con_prod.h"static pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;static pthread_cond_t cond=PTHREAD_COND_INITIALIZER;PNode head=NULL;void* product(void*i){  int goods=0;     while(1)  {    sleep(1);     pthread_mutex_lock(&lock);    goods=rand()%9999;    Insert(goods,&head);    printf("product success :%d",goods);    pthread_mutex_unlock(&lock);    pthread_cond_signal(&cond);  }  return (void*)0;}void * consume(void*j){  int p=0;  while(1)  {    pthread_mutex_lock(&lock);    if(empty()) pthread_cond_wait(&cond,&lock);    pop_front(&p);    printf("buy success :%d\n",p);    pthread_mutex_unlock(&lock);  }  return (void*)1;}int main(){   pthread_t tid,tid_2;   pthread_create(&tid,NULL,product,NULL);   pthread_create(&tid_2,NULL,consume,NULL);   pthread_join(tid,NULL);   return 0;}
Linux 下多线程的消费者-生产者模型 
    
    基于环形队列实现（应用了信号量） 
#ifndef CON_PROC_H
#define CON_PROC_H 
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
#define SIZE 10
int Bank[SIZE];
sem_t product_sem;
sem_t consume_sem;
void Init_sem()
{
   size_t nums= sizeof(Bank)/sizeof(Bank[0]);
   size_t idx=0;
   for( idx=0;idx<nums;idx++)
   {
     Bank[idx]=0;
   }
   sem_init(&product_sem,0,10);
   sem_init(&consume_sem,0,0);
}
void Destroy_all()
{
    sem_destroy(&product_sem);
    sem_destroy(&consume_sem);
    printf("delete sem success\n");
}
#endif
#include "con_prod.h"
PNode head=NULL;
int Bank[SIZE];
sem_t product_sem;
sem_t consume_sem;
void* product(void*i)
{
  int step=0;
  int goods=0;   
  while(1)
  {
    sem_wait(&product_sem); 
    Bank[step]=rand()%9999; 
    printf("product success,step:%d GOODs :%d\n",step,Bank[step]);
    step=(++step)%SIZE; 
    sem_post(&consume_sem);
    sleep(1);
  }
  return (void*)0;
}
void * consume(void*j)
{
  int p=0;
  int step=0;
  while(1)
  {
    sem_wait(&consume_sem);
    printf("buy success step:%d,GOODS:%d\n",step,Bank[step]);
    step=(++step)%SIZE;
    sem_post(&product_sem);
    sleep(2);
  }
  return (void*)1;
}
int main()
{
   Init_sem();
   pthread_t tid,tid_2;
    pthread_create(&tid,NULL,product,NULL);
   pthread_create(&tid_2,NULL,consume,NULL);
   pthread_join(tid,NULL);
   pthread_join(tid,NULL);
   Destroy_all();
   return 0;
}
    Linux 下多线程的消费者-生产者模型

多消费-多产生模型代码

    
#ifndef CON_PROC_H
#define CON_PROC_H 
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<semaphore.h>
#define SIZE 10
int Bank[SIZE];
sem_t product_sem;
sem_t consume_sem;
void Init_sem()
{
   size_t nums= sizeof(Bank)/sizeof(Bank[0]);
   size_t idx=0;
   for( idx=0;idx<nums;idx++)
   {
     Bank[idx]=0;
   }
   sem_init(&product_sem,0,10);
   sem_init(&consume_sem,0,0);
}
void Destroy_all()
{
    sem_destroy(&product_sem);
    sem_destroy(&consume_sem);
    printf("delete sem success\n");
}
#endif
#include "con_prod.h"int Bank[SIZE];sem_t product_sem;sem_t consume_sem;pthread_mutex_t pro_lock=PTHREAD_MUTEX_INITIALIZER;pthread_mutex_t con_lock=PTHREAD_MUTEX_INITIALIZER;void* product(void*i){  int step=0;  int goods=0;     while(1)  {    pthread_mutex_lock(&pro_lock);    sem_wait(&product_sem);     Bank[step]=rand()%9999;     printf("product success,tid:%u tep:%d  GOODs :%d\n",pthread_self(),step,Bank[step]);    step=(++step)%SIZE;     sem_post(&consume_sem);    pthread_mutex_unlock(&pro_lock);    sleep(2);  }  return (void*)0;}void* product_2(void*i){  int step=0;  int goods=0;     while(1)  {    pthread_mutex_lock(&pro_lock);    sem_wait(&product_sem);     Bank[step]=rand()%9999;     printf("product 2 success,tid:%u tep:%d  GOODs :%d\n",pthread_self(),step,Bank[step]);    step=(++step)%SIZE;     sem_post(&consume_sem);    pthread_mutex_unlock(&pro_lock);    sleep(2);  }return (void*)0;}void * consume(void*j){  int p=0;  int step=0;  while(1)  {    pthread_mutex_lock(&con_lock);    sem_wait(&consume_sem);    printf("conmuse 1 buy success ,tid:%u step:%d,GOODS:%d\n",pthread_self(),step,Bank[step]);    step=(++step)%SIZE;    sem_post(&product_sem);    pthread_mutex_unlock(&con_lock);    sleep(1);  }  return (void*)1;}void * consume_2(void*j){  int p=0;  int step=0;  while(1)  {    pthread_mutex_lock(&con_lock);    sem_wait(&consume_sem);    printf("consume 2 buy success ,tid:%u step:%d,GOODS:%d\n",pthread_self(),step,Bank[step]);    step=(++step)%SIZE;    sem_post(&product_sem);    pthread_mutex_unlock(&con_lock);    sleep(1);  }  return (void*)1;}int main(){   Init_sem();   pthread_t con,con_2,prod,prod_2;   pthread_create(&prod,NULL,product,NULL);   pthread_create(&con,NULL,consume,NULL);   pthread_create(&prod_2,NULL,product_2,NULL);   pthread_create(&con_2,NULL,consume_2,NULL);   pthread_join(con,NULL);   pthread_join(con_2,NULL);   pthread_join(prod,NULL);   pthread_join(prod_2,NULL);   Destroy_all();   return 0;}

   Linux 下多线程的消费者-生产者模型

标签：

相关文章