简单的生产者消费者模型

原创 于 2025-06-06 17:29:44 发布 · 247 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #信息与通信 #算法 #linux #信号处理

文章目录

场景

  三个生产者和五个消费者通过一个共享缓冲区进行操作，缓冲区用链表进行维护，生产后采用头插法插入，消费也同理。

两种思路

  1. 条件变量
  • 让线程等待某个条件成立，避免忙等待（busy-waiting）。
  • 通常和互斥锁（mutex）一起使用，构成 “等待-通知” 机制。
  1. 信号量
  • 控制对共享资源的访问数量（比如限制同时访问的线程数）。
  • 可以看作是一个计数器，线程通过 wait（P操作）和 post（V操作）来增减计数。

链表节点定义

//链表维护缓冲区
struct Node{
    int data;   //数据
    struct Node *ptr_next;  //指向下一节点的指针
};

1、条件变量思路

  • 声明以及初始化
//条件变量声明
pthread_cond_t cond;

//条件变量初始化
pthread_cond_init(&cond,NULL);
  • 生产者
void *produce(void *args){
    while (1){
        
        pthread_mutex_lock(&mutex);     //加锁
        struct Node *new_node=(struct Node*)malloc(sizeof(struct Node));
        new_node->ptr_next=head;
        head=new_node;
        new_node->data=rand()%1000;
        printf("thread: %ld has product %d in it\n",pthread_self(),new_node->data);
        pthread_mutex_unlock(&mutex);   //解锁

        pthread_cond_signal(&cond);     //生产结束后，通知消费者

        usleep(1000);
    }
    return NULL;
}
  • 消费者
void *custom(void *args){

    while(1){
        pthread_mutex_lock(&mutex);
        if(head!=NULL){         //有资源时 
            struct Node *temp=head;      //临时结点保存被“消费的”结点
            head=head->ptr_next;
            printf("thread: %ld has customed %d in it\n",pthread_self(),temp->data);
            free(temp);
            pthread_mutex_unlock(&mutex);
            usleep(1000);            
        }else{              //没有资源消费者只能等待

            pthread_cond_wait(&cond,&mutex);    //等待条件
            pthread_mutex_unlock(&mutex);
        }

    }
    
    return NULL;

}
  • 销毁条件变量
pthread_cond_destroy(&cond);

2、信号量思路

  • 思路总览
    在这里插入图片描述

  • 信号量声明与初始化

sem_t pro_s;    //生产者信号量
sem_t cus_s;    //消费者信号量

sem_init(&pro_s,0,5);
sem_init(&cus_s,0,0);
  • 生产者
//生产
void *produce(void *args){
    while (1){
        
        sem_wait(&pro_s);       //等待初始空位（5）

        pthread_mutex_lock(&mutex);     //加锁
        struct Node *new_node=(struct Node*)malloc(sizeof(struct Node));
        new_node->ptr_next=head;
        head=new_node;
        new_node->data=rand()%1000;
        printf("thread: %ld has product %d in it\n",pthread_self(),new_node->data);
        pthread_mutex_unlock(&mutex);   //解锁

        sem_post(&cus_s);       //生产完成后，通知消费者

        usleep(1000);
    }
    return NULL;
}
  • 消费者
void *custom(void *args){

    while(1){
        
        sem_wait(&cus_s);   //等待资源

        pthread_mutex_lock(&mutex);

        struct Node *temp=head;      //临时结点保存被“消费的”结点
        head=head->ptr_next;
        printf("thread: %ld has customed %d in it\n",pthread_self(),temp->data);
        free(temp);
        pthread_mutex_unlock(&mutex);

        sem_post(&pro_s);   //消费结束后通知生产者

        usleep(1000);            
        }
    
    return NULL;

}

条件变量全部实现

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

//互斥锁声明
pthread_mutex_t mutex;

//条件变量声明
pthread_cond_t cond;


//链表维护缓冲区
struct Node{
    int data;   //数据
    struct Node *ptr_next;  //指向下一节点的指针
};

struct Node *head=NULL;   //头结点


//生产
void *produce(void *args){
    while (1){
        
        pthread_mutex_lock(&mutex);     //加锁
        struct Node *new_node=(struct Node*)malloc(sizeof(struct Node));
        new_node->ptr_next=head;
        head=new_node;
        new_node->data=rand()%1000;
        printf("thread: %ld has product %d in it\n",pthread_self(),new_node->data);
        pthread_mutex_unlock(&mutex);   //解锁

        pthread_cond_signal(&cond);     //生产结束后，通知消费者

        usleep(1000);
    }
    return NULL;
}

//消费，头删法
void *custom(void *args){

    while(1){
        pthread_mutex_lock(&mutex);
        if(head!=NULL){         //有资源时 
            struct Node *temp=head;      //临时结点保存被“消费的”结点
            head=head->ptr_next;
            printf("thread: %ld has customed %d in it\n",pthread_self(),temp->data);
            free(temp);
            pthread_mutex_unlock(&mutex);
            usleep(1000);            
        }else{              //没有资源消费者只能等待

            pthread_cond_wait(&cond,&mutex);    //等待条件
            pthread_mutex_unlock(&mutex);
        }

    }
    
    return NULL;

}

int main(){

    pthread_mutex_init(&mutex,NULL);            //互斥锁初始化
    pthread_cond_init(&cond,NULL);              //条件变量初始化
    pthread_t pro_thread[3],cus_thread[5];      //三个生产者，五个消费者

    // 分别创建生产者线程
    for (int i = 0; i < 3; i++) {
        pthread_create(&pro_thread[i], NULL, produce, NULL);
    }

    // 分别创建消费者线程
    for (int j = 0; j < 5; j++) {
        pthread_create(&cus_thread[j], NULL, custom, NULL);
    }

    // 分离所有线程
    for (int i = 0; i < 3; i++) {
        pthread_detach(pro_thread[i]);
    }
    for (int j = 0; j < 5; j++) {
        pthread_detach(cus_thread[j]);
    }


    //防止主线程退出,从而引发段错误
    while(1) {
        sleep(1);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    pthread_exit(NULL);     //退出主线程

    return 0;
}

信号量全部实现

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>

//互斥锁声明
pthread_mutex_t mutex;

//信号量声明
sem_t pro_s;    //生产者信号量
sem_t cus_s;    //消费者信号量


//链表维护缓冲区
struct Node{
    int data;   //数据
    struct Node *ptr_next;  //指向下一节点的指针
};

struct Node *head=NULL;   //头结点


//生产
void *produce(void *args){
    while (1){
        
        sem_wait(&pro_s);       //等待初始空位（5）

        pthread_mutex_lock(&mutex);     //加锁
        struct Node *new_node=(struct Node*)malloc(sizeof(struct Node));
        new_node->ptr_next=head;
        head=new_node;
        new_node->data=rand()%1000;
        printf("thread: %ld has product %d in it\n",pthread_self(),new_node->data);
        pthread_mutex_unlock(&mutex);   //解锁

        sem_post(&cus_s);       //生产完成后，通知消费者

        usleep(1000);
    }
    return NULL;
}

//消费，头删法
void *custom(void *args){

    while(1){
        
        sem_wait(&cus_s);   //等待资源

        pthread_mutex_lock(&mutex);

        struct Node *temp=head;      //临时结点保存被“消费的”结点
        head=head->ptr_next;
        printf("thread: %ld has customed %d in it\n",pthread_self(),temp->data);
        free(temp);
        pthread_mutex_unlock(&mutex);

        sem_post(&pro_s);   //消费结束后通知生产者

        usleep(1000);            
        }
    
    return NULL;

}

int main(){

    pthread_mutex_init(&mutex,NULL);            //互斥锁初始化

    sem_init(&pro_s,0,5);
    sem_init(&cus_s,0,0);

    pthread_t pro_thread[3],cus_thread[5];      //三个生产者，五个消费者

    // 分别创建生产者线程
    for (int i = 0; i < 3; i++) {
        pthread_create(&pro_thread[i], NULL, produce, NULL);
    }

    // 分别创建消费者线程
    for (int j = 0; j < 5; j++) {
        pthread_create(&cus_thread[j], NULL, custom, NULL);
    }

    // 分离所有线程
    for (int i = 0; i < 3; i++) {
        pthread_detach(pro_thread[i]);
    }
    for (int j = 0; j < 5; j++) {
        pthread_detach(cus_thread[j]);
    }


    //防止主线程退出,从而引发段错误
    while(1) {
        sleep(1);
    }

    pthread_mutex_destroy(&mutex);


    pthread_exit(NULL);     //退出主线程

    return 0;
}
C语言编写生产者消费者模型
qq_39605374的博客
08-15 586
生产者线程的主要作用是向缓冲区中写入元素，而消费者线程的主要作用是从缓冲区中取出元素并消费。通过使用互斥锁和条件变量等同步机制，可以有效地确保多个线程之间的协调与同步，从而避免了竞态条件和死锁等问题的发生。值得注意的是，在生产者线程中，如果缓冲区已经满了，就需要进入等待状态，直到有空闲位置。同样地，在消费者线程中，如果缓冲区已经空了，就需要等待直到有元素可以被消费。在这个问题中，有两类线程：生产者和消费者，它们共享一个固定大小的缓冲区。在这里，我们先初始化了缓冲区，并创建了生产者和消费者线程。
来用C语言实写一个生产者消费者模型吧！！
Wensxiao的博客
06-04 448
#include <cstdlib> #include <cstdio> #include <pthread.h> #include <cstring> #include <ctime> #include <sys/time.h> #define PRODUCTS_MAX 150 #define PRODUCER_MAX 20 #define CONSUMER_MAX 10 #define LOAD 500 #define WO.
生产者消费者模型---详解及代码实现
热门推荐
lvxin15353715790的博客
04-09 5万+
概念 生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。 321原则 三种角色：生产者、消费者、仓库 两种关...
C语言实现生产者消费者模型(线程、信号量、互斥锁)
weixin_43030270的博客
11-10 2820
C 线程
LinuxC语言实现生产者和消费者模型
08-30
LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型LinuxC语言实现生产者和消费者模型
Java实现简易生产者消费者模型过程解析
08-19
在本文中，我们将通过一个简单的示例代码介绍Java实现简易生产者消费者模型的过程。 二、Java实现生产者消费者模型 在Java中，生产者消费者模型可以通过使用同步机制和wait/notify机制来实现。在下面的示例代码中...
Qt入门练习项目——生产者消费者模型.zip
08-01
**Qt入门练习项目——生产者消费者模型** 在编程领域，生产者消费者模型是一种常见的多线程同步问题的解决方案。这个模型通常用于处理数据流的异步处理，其中一个或多个线程（生产者）生成数据，而其他线程（消费者...
理解生产者消费者模型及在Python编程中的运用实例
12-25
什么是生产者消费者模型 在 工作中，大家可能会碰到这样一种情况：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产 生数据的模块，就形象地称为...
python之生产者消费者模型实现详解
09-18
文章中提供的代码是一个简单生产者消费者模型的实例，包括一个生产者函数`prodcer`，它负责制造包子，并将它们放入队列中。还有消费者函数`consumer`，它从队列中取出包子并消耗它。示例中使用了三个消费者`c1`、`c2...
生产者消费者线程模型流程图
最新发布
07-18
绘制生产者消费者模型流程图；制作生产者消费者模型流程图。 生产者与消费者流程图绘制；生产者和消费者流程图绘制。 制作生产者消费者流程示意图；生产者消费者流程示意图绘制。 生产者消费者流程图绘制工作；生产...
C语言实现操作系统中生产者消费者
06-26
用C-Free5软件写的，主函数为Int类型。在其他软件上可能要改成void，算法方面没有什么问题。如果要缓冲池满就把生产者M1的数改的比消费者M2的高，要缓冲池空则相反。
生产者——消费者 c语言
11-27
生产者——消费者 c语言 C语言 #include #define size 5 int empty,full,in,out,a[size]={0},i,m=1; void produce() { int j; if(empty>0) { empty--; a[in]=1; printf("生产一件产品,1为继续生产，2为消费\n"); in=(in+1)%size; scanf("%d",&j); switch(j) { case 1: i=j;break; case 2: i=j;break; default: printf("结束操作");m=0; } full++; } else
C语言实现生产者消费者问题
05-27
C语言实现生产者消费者问题，分配具有n个缓冲区的缓冲池，作为共享资源。 定义两个资源型信号量empty 和full，empty信号量表示当前空的缓冲区数量，full表示当前满的缓冲区数量。 定义互斥信号量mutex，当某个进程访问缓冲区之前先获取此信号量，在对缓冲区的操作完成后再释放此互斥信号量。以此实现多个进程对共享资源的互斥访问。 创建3进程（或者线程）作为生产者，4个进程（或者线程）作为消费者。创建一个文件作为数据源，文件中事先写入一些内容作为内容。 编写代码实现生产者进程的工作内容，即从文件中读取数据，然后申请一个empty信号量，和互斥信号量，然后进入临界区操作将读取的数据放入此缓冲区中。并释放empty信号量和互斥信号量。
C例子：生产者与消费者问题
01-17
该程序是我写的博客“一起talk C栗子吧（第一百零六回：C语言实例--生产者与消费者问题二）”的配套程序，共享给大家使用
Linux线程 --- 生产者消费者模型（C语言）
mjmmm的博客
08-24 1218
生产者和消费者之间互斥且同步。
生产者消费者模型的两种C语言实现
weixin_38299404的博客
04-16 822
使用互斥锁和条件变量实现的生产者和消费者模型。使用互斥锁和信号量实现的生产者和消费者模型。
C++语法｜C++11标准实现生产者消费者模型
糖炒栗子
05-20 1205
在多线程编程中，生产者-消费者问题是一个经典的同步问题，它涉及到两种类型的线程：生产者和消费者。生产者负责生成数据放入缓冲区，而消费者则从缓冲区中取出数据。本文将详细介绍如何使用 C++11 的新特性来实现这一模型。首先，定义了一个名为Queue的类，它是生产者和消费者共享的队列。该队列内部使用std::queue来存储数据，并配有std::mutex和std::condition_variable来实现线程同步。put方法：当生产者生成一个新的物品时，首先会获取互斥锁。
Linux多线程编程-生产者与消费者模型详解与实现（C语言）
qq_42037383的博客
07-14 1127
生产者-消费者模型是并发编程中的经典问题，描述了多个线程（或进程）如何安全、有效地共享有限的缓冲区资源。：负责生成数据或者将数据放置到共享缓冲区中。：负责从共享缓冲区中取出数据并进行处理或消费。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

There is.no way

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值