linux进程线程下简单的消费者和生产者

最新推荐文章于 2021-04-28 21:49:08 发布
最新推荐文章于 2021-04-28 21:49:08 发布
阅读量447 收藏
点赞数
分类专栏： Linux 文章标签： 线程 生产者消费者问题 多线程 pthread 锁引用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/magiclyj/article/details/70880178
版权

在大家学习进程或者线程的时候肯定都会遇到生产者和消费者问题，也称为有界缓冲区。生产者消费者和现实中类似，只是在编程中一切都是数据而已，生产者和消费者简单的有一对一的关系，复杂的就有一对多、多对一、多对多的关系，要注意的是生产者和消费者都必须是在操作一块内存或者文件。在这里我仅为了熟练线程操作，使用线程来完成，并选则简单的增减数字来模拟生产者消费者关系，为了保证每一个线程可以执行完成在这里应用了互斥锁pthread_mutex_lock(pthread_mutex_t mutex)和等待唤醒pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t mutex)、pthread_cond_signal(pthread_cond_t* cond)函数，详细使用查阅man手册3;下面我们来看看图解和代码实现。

1、一对一的生产者和消费者：

这里写图片描述
代码：

#include<iostream>
#include<pthread.h>
#include<unistd.h>
using namespace std;
int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
void *Product(void *arg)
{
    //pthread_mutex_lock(&mutex);
    while(1)
    {
        pthread_mutex_lock(&mutex);
        //int index = *(int *)arg;
        if(count >= 500)
        {
            pthread_cond_signal(&cond1);
            pthread_cond_wait(&cond, &mutex);
        }
        ++count;
        cout<<"This is product:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }

}
void *Consumer(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count <= 0)
        {
            pthread_cond_signal(&cond);
            pthread_cond_wait(&cond1,&mutex);
        }
        --count;
        cout<<"This is Consumer:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
int main()
{
    pthread_t tid[2];
    while(1)
    {
        pthread_create(&tid[0],NULL,Product,NULL);
        pthread_create(&tid[1],NULL,Consumer,NULL);
        pthread_join(tid[0], NULL);
        pthread_join(tid[1], NULL);
        break;
    }
    return 0;
}

这里写图片描述

2、一对多的生产者和消费者们：

这里写图片描述

#include<iostream>
#include<unistd.h>
#include<pthread.h>
using namespace std;
int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
void *Product(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count >= 15)
        {
            pthread_cond_signal(&cond1);
            pthread_cond_wait(&cond, &mutex);
        }
        ++count;
        cout<<"This is product:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }

}
void *Consumer1(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count <= 0)
        {
            pthread_cond_signal(&cond);
            pthread_cond_wait(&cond1,&mutex);
        }
        --count;
        cout<<"This is Consumer1:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
void *Consumer2(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count <= 0)
        {
            pthread_cond_signal(&cond);
            pthread_cond_wait(&cond1,&mutex);
        }
        --count;
        cout<<"This is Consumer2:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
void *Consumer3(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count <= 0)
        {
            pthread_cond_signal(&cond);
            pthread_cond_wait(&cond1,&mutex);
        }
        --count;
        cout<<"This is Consumer3:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
void *Consumer4(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count <= 0)
        {
            pthread_cond_signal(&cond);
            pthread_cond_wait(&cond1,&mutex);
        }
        --count;
        cout<<"This is Consumer4:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
int main()
{
    pthread_t tid[5];
    while(1)
    {
        pthread_create(&tid[0],NULL,Product,NULL);
        pthread_create(&tid[1],NULL,Consumer1,NULL);
        pthread_create(&tid[2],NULL,Consumer2,NULL);
        pthread_create(&tid[3],NULL,Consumer3,NULL);
        pthread_create(&tid[4],NULL,Consumer4,NULL);
        for(int i=0; i<5; ++i)
        {
            pthread_join(tid[i], NULL);
        }
    }
    return 0;
}

这里写图片描述

3、多对一的生产者们和消费者：

这里写图片描述
代码：

#include<iostream>
#include<unistd.h>
#include<pthread.h>
using namespace std;
int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
void *Product1(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count >= 15)
        {
            pthread_cond_signal(&cond1);
            pthread_cond_wait(&cond, &mutex);
        }
        ++count;
        cout<<"This is product1:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }

}
void *Product2(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count >= 15)
        {
            pthread_cond_signal(&cond1);
            pthread_cond_wait(&cond, &mutex);
        }
        ++count;
        cout<<"This is product2:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
void *Product3(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count >= 15)
        {
            pthread_cond_signal(&cond1);
            pthread_cond_wait(&cond, &mutex);
        }
        ++count;
        cout<<"This is product3:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
void *Consumer(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count <= 0)
        {
            pthread_cond_signal(&cond);
            pthread_cond_wait(&cond1,&mutex);
        }
        --count;
        cout<<"This is Consumer:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
int main()
{
    pthread_t tid[4];
    while(1)
    {
        pthread_create(&tid[0],NULL,Product1,NULL);
        pthread_create(&tid[1],NULL,Product2,NULL);
        pthread_create(&tid[2],NULL,Product3,NULL);
        pthread_create(&tid[3],NULL,Consumer,NULL);
        for(int i=0; i<4; ++i)
        {
            pthread_join(tid[i], NULL);
        }

    }
    return 0;
}

这里写图片描述

4、多对多的生产者和消费者们：

这里写图片描述

#include<iostream>
#include<unistd.h>
#include<pthread.h>
using namespace std;
int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
void *Product1(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count >= 15)
        {
            pthread_cond_signal(&cond1);
            pthread_cond_wait(&cond, &mutex);
        }
        ++count;
        cout<<"This is product1:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }

}
void *Product2(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count >= 15)
        {
            pthread_cond_signal(&cond1);
            pthread_cond_wait(&cond, &mutex);
        }
        ++count;
        cout<<"This is product2:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
void *Product3(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count >= 15)
        {
            pthread_cond_signal(&cond1);
            pthread_cond_wait(&cond, &mutex);
        }
        ++count;
        cout<<"This is product3:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
void *Consumer1(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count <= 0)
        {
            pthread_cond_signal(&cond);
            pthread_cond_wait(&cond1,&mutex);
        }
        --count;
        cout<<"This is Consumer1:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
void *Consumer2(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count <= 0)
        {
            pthread_cond_signal(&cond);
            pthread_cond_wait(&cond1,&mutex);
        }
        --count;
        cout<<"This is Consumer2:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
void *Consumer3(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count <= 0)
        {
            pthread_cond_signal(&cond);
            pthread_cond_wait(&cond1,&mutex);
        }
        --count;
        cout<<"This is Consumer3:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
void *Consumer4(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(count <= 0)
        {
            pthread_cond_signal(&cond);
            pthread_cond_wait(&cond1,&mutex);
        }
        --count;
        cout<<"This is Consumer4:> "<<count<<endl;
        pthread_mutex_unlock(&mutex);
    }
}
int main()
{
    pthread_t tid[7];
    while(1)
    {
        pthread_create(&tid[0],NULL,Product1,NULL);
        pthread_create(&tid[1],NULL,Product2,NULL);
        pthread_create(&tid[2],NULL,Product3,NULL);
        pthread_create(&tid[3],NULL,Consumer1,NULL);
        pthread_create(&tid[4],NULL,Consumer2,NULL);
        pthread_create(&tid[5],NULL,Consumer3,NULL);
        pthread_create(&tid[6],NULL,Consumer4,NULL);
        for(int i=0; i<7; ++i)
        {
            pthread_join(tid[i], NULL);
        }

    }
    return 0;
}

这里写图片描述
在最后也说一下本人再学习线程中遇到的一个疑问就是创建简单的多线的时候，线程的创建先后顺序会乱，这是因为现在的电脑都是四核四线或者四核八线的配置，在程序执行的时候短时间会把每个线程的创建分配给每个内核的线程同时执行，由于不一定每个内核的线程都是空闲的所以会出现创建顺序的先好颠倒现象，并不是我们想象的线程有缓存区。
这里写图片描述
这里写图片描述
这里写图片描述

magiclyj
关注
专栏目录
linux多线程学习（七）——实现“生产者和消费者”
阿堂的专栏
01-20 4120
在上一篇文章中，利用信号量实现了线程间的互斥，这一篇将要利用信号量的互斥同步机制来实现一个经典实例，就是“生产者和消费者”。1、简单描述生产者和消费者的问题。有一个缓冲区和两个线程：生产者和消费者。生产者把产品放入缓冲区，而消费者从缓冲区中拿走。当缓冲区满时，生产者必须等待；另外，当缓冲区空时，消费者必须等待，并且缓冲区不能同时进行生产者和消费者的操作。#include #in
Linux创建两个生产者进程,以生产者消费者为例实现Linux进程线程控制
weixin_28715953的博客
04-29 2075
操作系统课程设计实验报告设计题目一：Linux进程线程控制——以生产者消费者为例实现进程线程控制——by一、设计题目要求加深理解进程和程序、进程和线程之间的联系与区别；深入理解进程及线程的重要数据结构及实现机制；熟悉进程及线程的创建、执行、阻塞、唤醒、终止等控制方法；学会使用进程及线程开发应用程序。二、程序设计思路及流程图程序功能简介：生产者功能描述：在同一个进程地址空间内执行两个线程。生产者线程...
Linux下生产者与消费者的线程实现
digangjian2366的博客
01-09 127
代码见《现代操作系统》 第3版。 为了显示效果，添加了printf()函数来显示运行效果 1 #include<stdio.h> 2 #include<pthread.h> 3 #define MAX 20 4 pthread_mutex_t the_mutex; 5 pthread_cond_t condc, condp; 6 in...
Linux下的简单生产、消费模型的实现（上）
Compass♂
12-14 1533
生产消费模型是信号量的最典型的应用实例。然而实际操作系统中P、V操作并不是如理想模型那样方便使用的，这里以Linux为例描述了生产、消费模型的实现方法，同时涉及了Linux下共享内存、信号量的基本操作。如有不正确之处，请大家指正，谢谢！ 一、Linux下信号量的建立要建立一个信号量，首先要给信号量一个主键，即给信号量命名。Linux下的信号量与Windows有很大的不同，Windows以一个字符串
【Linux】生产者与消费者模型以及代码实现
进阶之路
11-09 684
生产者消费者模型 为什么要使用生产者消费者模型？？ 生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取数据，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。 关...
使用多线程程序模拟实现单生产者/多消费者问题（Linux下C语言）。
11-25
使用多线程程序模拟实现单生产者/多消费者问题。 要求“生产者”随机产生一个整数，“消费者 1”将这个整数加 1 后输出，“消 费者 2”将这个整数加 2 后输出，“消费者 3”将这个整数加 3 后输出，“消 费者 4”将这个整数加 4 后输出。当程序接收到键盘输入“q”或“Q”时退 出。
多进程同步方法解决生产者-消费者问题(linux线程实现)
05-15
设计要求:(1)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容,当前指针位置和生产者/消费者线程的标识符.(2)生产者和消费者各有两个以上.(3)多个生产者或多个消费者之间须有共享对缓冲区...
（Linux C）利用多进程或多线程模拟实现生产者/消费者问题
02-11
生产者和消费者可以各自运行在独立的进程中，通过信号量（semaphore）来同步对缓冲区的访问。信号量可以表示缓冲区的空闲位置或者可用数据的数量。例如，当缓冲区满时，生产者进程会阻塞直到消费者消费掉一些数据；...
Linux c语言多线程实现生产者/消费者问题
03-13
以生产者/消费者问题为例来阐述Linux线程的控制和通信。一组生产者线程与一组消费者线程通过缓冲区发生联系。生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。缓冲区有N 个，是一个环形的缓冲池。 ...
Linux下生产者消费者问题的实现
06-01
利用互斥锁和计数信号完成生产者消费者问题 一组生产者进程和一组消费者进程共享一个初始为空、大小为n的缓冲区，只有缓冲区没满时，生产者才把消息放入到缓冲区，否则必须等待；只有缓冲区不空时，消费者才能从中取出消息，否则必须等待。由于缓冲区是临界资源，它只允许一个生产者放入消息，或者一个消费者从中取出消息。 生产者和消费者对缓冲区互斥访问是互斥关系，同时生产者和消费者又是一个相互协作的关系，只有生产者生产之后，消费者才能消费，他们又是同步关系。 信号量设置：信号量mutex作为互斥信号量，它用于控制互斥访问缓冲池，互斥信号量初值为1；信号量full用于记录当前缓冲池中“满”缓冲区数，初值为0。信号量empty用于记录当前缓冲池中“空”缓冲区数，初值为n。 主函数负责接收参数，初始化信号量，创建生产者线程，创建消费者线程，睡眠一段时间后，结束程序
Linux进程间通信之生产者消费者
01-20
通过生产者与消费者问题介绍Linux下进程通信方（IPC）法，包括管道（有名管道），信号，消息队列，信号灯与共享内存。其中消息队列，信号灯与共享内存是基于system V系统。v0.1版本。
生产者消费者问题（信号量）（linux）实现代码
01-02
参考教材中的生产者消费者算法，创建5个进程，其中两个进程为生产者进程，3个进程为消费者进程。一个生产者进程试图不断地在一个缓冲中写入大写字母，另一个生产者进程试图不断地在缓冲中写入小写字母。3个消费者不断地从缓冲中读取一个字符并输出。为了使得程序的输出易于看到结果，仿照的实例程序，分别在生产者和消费者进程的合适的位置加入一些随机睡眠时间。
linux多进程生产消费
07-31
linux多进程生产消费
linux下使用线程实现生产者消费者问题
YanLeaon的博客
12-31 1739
linux下使用线程实现生产者消费者问题
简单的生产者与消费者实现
疯狂的草儿
12-15 130
同步堆栈，用于存储。 public class SyncStack { private int index = 0; private char[] data = new char[6]; public synchronized void push(char c){ while(index == data.length){ try{ this.wait()...
linux生产者消费者进程,Linux进程互斥——生产者－消费者
weixin_29865939的博客
04-28 1244
Linux进程互斥(二)模拟生产者－消费者的示例程序本示例主要体现进程间的直接制约关系，由于使用共享存储区，也存在间接制约关系。进程分为服务进程和客户进程，服务进程只有一个，作为消费者，在每次客户进程改变共享存储区内容时显示其数值。各客户进程作为生产者，如果共享存储区内容已经显示(被消费)，可以接收用户从键盘输入的整数，放在共享存储区。编译后执行，第一个进程实例将作为服务进程，提示：ACT CON...
【Linux】生产者消费者模型
Cheng_913的博客
04-11 1289
什么是生产者-消费者模型？ 　　生产者-消费者是非常著名的一个问题。它的描述是：有一群生产者进程在生产产品，并将这些产品提供给消费者进程去消费，为使生产者与消费者能并发的执行，在两者之间设置了具有n个缓冲区的缓冲池，生产者进程将其所生产的产品放入一个缓冲区中；消费者进程可从一个缓冲区中取走产品。他们之间必须保持同步，即：不允许消费者到一个空的缓冲区中去取产品，也不允许生产者向一个已经装满产品的缓...
Linux下生产者消费者多线程与银行家算法实践
本实验报告主要探讨的是在Unix操作系统环境下进行多线程编程，涉及两个关键任务：生产者消费者问题的实现和银行家算法的实践。首先，针对生产者消费者问题，实验设计了一个有界缓冲区，其中包含10个存储单元，用于...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值