生产者-消费者问题 ——by一宇 2021-01-04

最新推荐文章于 2022-01-17 14:16:51 发布
最新推荐文章于 2022-01-17 14:16:51 发布
阅读量199 收藏 5
点赞数
分类专栏： 操作系统 文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45011621/article/details/112208338
版权

生产者-消费者问题

目录

1.1 整型信号量

1.1.1 Windows环境

直接运行如下代码即可

#include <stdio.h>
#include <pthread.h>//线程的创建
#include <windows.h>
#define N 100
#define true 1
#define producerNum  10
#define consumerNum  5
#define sleepTime 2000

typedef int semaphore;
typedef int item;
item buffer[N] = {0};
int in = 0;
int out = 0;
int proCount = 0;
semaphore mutex = 1, empty = N, full = 0;

//生产者
void * producer(void * a){
    while(true){
        while(mutex <= 0);//缓冲区位置不够，一直循环等待，S<=0不断【检测测试】
        mutex--;//实现互斥的P操作【上锁】，缓冲区位置足够，占用一个位置资源
        
        proCount++;//生产一个产品
        printf("生产一个产品ID%d, 缓冲区位置为%d\n",proCount,in);

        while(empty <= 0){
            printf("缓冲区已满！\n");
        }
        empty--;//实现同步的P操作

        buffer[in] = proCount;
        in = (in + 1) % N;    
        
        mutex++;//实现互斥的V操作【开锁】
        full++;//实现同步的V操作
        Sleep(sleepTime);
    }
}

//消费者
void * consumer(void *b){
    while(true){
        while(full <= 0){
            printf("缓冲区为空！\n");
        }
        full--;//实现同步的P操作

        while(mutex <= 0);
        mutex--;//实现互斥的P操作【上锁】

        int nextc = buffer[out];
        buffer[out] = 0;//消费完将缓冲区设置为0

        out = (out + 1) % N;

        mutex++;//实现互斥的V操作【开锁】
        empty++;//实现同步的V操作

        printf("\t\t\t\t\t消费一个产品ID%d,缓冲区位置为%d\n", nextc,out);
        Sleep(sleepTime);
    }
}

//主函数
int main()
{
    pthread_t threadPool[producerNum+consumerNum];//创建线程池
    int i;
    for(i = 0; i < producerNum; i++){
        pthread_t temp;//创建一个生产者线程
        if(pthread_create(&temp, NULL, producer, NULL) == -1){
            printf("ERROR: fail to create producer%d\n", i);
            exit(1);
        }
        threadPool[i] = temp;//将创建的生产者线程放入线程池
    }//创建生产者进程放入线程池

    for(i = 0; i < consumerNum; i++){
        pthread_t temp;//创建一个消费者线程
        if(pthread_create(&temp, NULL, consumer, NULL) == -1){
            printf("ERROR: fail to create consumer%d\n", i);
            exit(1);
        }
        threadPool[i+producerNum] = temp;//将创建的消费者线程放入线程池
    }//创建消费者进程放入线程池

    void * result;
    for(i = 0; i < producerNum+consumerNum; i++){
        if(pthread_join(threadPool[i], &result) == -1){
            printf("ERROR: fail to recollect\n");
            exit(1);
        }
    }//运行线程池
    return 0;
}

运行结果部分截图如下：
1

1.1.2 Unix环境

1、代码如下

#include <stdio.h>
#include <pthread.h>//线程的创建
#define N 100
#define true 1
#define producerNum  10
#define consumerNum  5

typedef int semaphore;
typedef int item;
item buffer[N] = {0};
int in = 0;
int out = 0;
int proCount = 0;
semaphore mutex = 1, empty = N, full = 0;

//生产者
void * producer(void * a){
    while(true){
        while(mutex <= 0);//缓冲区位置不够，一直循环等待，S<=0不断【检测测试】
        mutex--;//实现互斥的P操作【上锁】，缓冲区位置足够，占用一个位置资源
        
        proCount++;//生产一个产品
        printf("生产一个产品ID%d, 缓冲区位置为%d\n",proCount,in);

        while(empty <= 0){
            printf("缓冲区已满！\n");
        }
        empty--;//实现同步的P操作

        buffer[in] = proCount;
        in = (in + 1) % N;     
       
        mutex++;//实现互斥的V操作【开锁】
        full++;//实现同步的V操作
    }
}

//生产者
void * producer(void * a){
    while(true){
        while(mutex <= 0);//缓冲区位置不够，一直循环等待，S<=0不断【检测测试】
        mutex--;//实现互斥的P操作【上锁】，缓冲区位置足够，占用一个位置资源
        
        proCount++;//生产一个产品
        printf("生产一个产品ID%d, 缓冲区位置为%d\n",proCount,in);

        while(empty <= 0){
            printf("缓冲区已满！\n");
        }
        empty--;//实现同步的P操作

        buffer[in] = proCount;
        in = (in + 1) % N;    
        
        mutex++;//实现互斥的V操作【开锁】
        full++;//实现同步的V操作
        Sleep(sleepTime);
    }
}

//消费者
void * consumer(void *b){
    while(true){
        while(full <= 0){
            printf("缓冲区为空！\n");
        }
        full--;//实现同步的P操作

        while(mutex <= 0);
        mutex--;//实现互斥的P操作【上锁】

        int nextc = buffer[out];
        buffer[out] = 0;//消费完将缓冲区设置为0

        out = (out + 1) % N;

        mutex++;//实现互斥的V操作【开锁】
        empty++;//实现同步的V操作

        printf("\t\t\t\t\t消费一个产品ID%d,缓冲区位置为%d\n", nextc,out);
    }
}

//主函数
int main()
{
    pthread_t threadPool[producerNum+consumerNum];//创建线程池
    int i;
    for(i = 0; i < producerNum; i++){
        pthread_t temp;//创建一个生产者线程
        if(pthread_create(&temp, NULL, producer, NULL) == -1){
            printf("ERROR: fail to create producer%d\n", i);
            exit(1);
        }
        threadPool[i] = temp;//将创建的生产者线程放入线程池
    }//创建生产者进程放入线程池

    for(i = 0; i < consumerNum; i++){
        pthread_t temp;//创建一个消费者线程
        if(pthread_create(&temp, NULL, consumer, NULL) == -1){
            printf("ERROR: fail to create consumer%d\n", i);
            exit(1);
        }
        threadPool[i+producerNum] = temp;//将创建的消费者线程放入线程池
    }//创建消费者进程放入线程池

    void * result;
    for(i = 0; i < producerNum+consumerNum; i++){
        if(pthread_join(threadPool[i], &result) == -1){
            printf("ERROR: fail to recollect\n");
            exit(1);
        }
    }//运行线程池
    return 0;
}

2、编译运行

错误编译：

~$ gcc -o fileName fileName.c

2

正确编译：

/*
注意：该程序为多线程程序
1、需要添加头文件#inlcude <pthread.h>才能创建线程
2、编译时需要手动连接pthread库
	因为pthread不是Linux系统的默认库，而是POSIX线程库。连接时需要使用库libpthread.a。在代码中使用pthread_create、pthrea_join等时，在编译中要加-lpthread参数。在Linux中将其作为一个库来使用，因此加上 -lpthread（或-pthread）以显式链接该库。
*/
~$ gcc fileName.c -lpthread -o fileName //编译
~$ ./fileName //运行

运行结果部分截图如下：
在这里插入图片描述

1.2 记录型信号量

1、代码如下

#include <stdio.h>
#include <windows.h>
#include <unistd.h>
#define N 100
#define true 1
#define producerNum  10
#define consumerNum  5
#define sleepTime 2000

typedef struct{
	int value;
	struct process_control_block *list;
}semaphore;

void wait(semaphore *S){
	S->value--;
	if(S->value<0)block(S->list);
}

void signal(semaphore *S){
	S->value++;
	if(S->value<=0)wakeup(S->list);
}

typedef int item;
item buffer[N] = {0};
int in = 0;
int out = 0;
int proCount = 0;
semaphore *mutex,*empty,*full;

 
void* producer(){
	int i = 0;
	do{
		wait(empty);
		wait(mutex);
		
		proCount++;
		printf("生产一个产品ID%d，缓冲区位置为%d\n",proCount,in);
		while(empty->value<=0){
			printf("缓冲区已满！\n");
		}
		buffer[in] = proCount;
		in = (in+1) % N;
		
		signal(mutex);
		signal(full);
	    Sleep(sleepTime);
	}while(i<100);
}
 
void* consumer(){
	int i=0;
	do{
		while(full->value <= 0){
            printf("缓冲区为空！\n");
        }
		wait(full);
		wait(mutex);
		
		int nextc = buffer[out];
		out = (out+1) % N;
		
		signal(mutex);
		signal(empty); 
		
		printf("\t\t\t\t\t消费一个产品ID%d,缓冲区位置为%d\n", nextc,out);
		Sleep(sleepTime);
	}while(i<15);
	return NULL;
}
int main(){
	mutex->value = 1;
	empty->value = N;
	full->value = 0;
	producer();
	consumer();
	return 0;
}

问题：block和wakeup未实现

——by一宇 2020-01-04
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45011621/article/details/112208338

Yoloº
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
互斥锁(mutex)
世间所有的相遇都是久别重逢
09-03 10万+
Linux中提供一把互斥锁mutex（也称之为互斥量）。 每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。 但通过“锁”就将资源的访问变成互斥操作，而后与时间有关的错误也不会再产生了。 但，应注意：同一时刻，只能有一个线程持有该锁。 当A线程对某个全局变量加锁访问，B在访问前尝试加锁，拿不到锁，B阻塞。C线程不去加锁，而直接访问该全局变量，依然能够访问，但会出...
C语言实战——生产者消费者问题
qq_39079631的博客
06-06 9396
C语言实战——生产者消费者问题 方法摘要 生产者消费者共享缓冲区，生产者向缓冲区中放数据，消费者从缓冲取中取数据，当缓冲区中被放满时，生产者进程就必须进入挂起状态，直到消费者从缓冲中取走数据时，生产者才能继续向缓冲区中存放数据，同样当缓冲取中没有数据时，消费者进程就必须进入挂起休眠状态，直到生产者向缓冲区中放入数据时，消费者才能被唤醒继续从缓冲区中取走数据。 简写代码 对于生产者： void producer(void) { int item; while(1) { item = produc
经典进程同步问题——生产者消费者（多生产者多消费者）
拿头去拼啊
11-10 4455
生产者-消费者问题 问题描述：一组生产者进程和一组消费者进程共享一个初始为空、大小为n的缓冲区，只有缓冲区没有满的时候，生产者才能把消息放入缓冲区，否则得等待缓冲区空闲出来；只有缓冲区不空的时，消费者才能从缓冲区取出消息，否则必须等待。由于缓冲区是临界资源，它只允许一个生产者放入消息，或一个消费者取出消息。 问题分析： 关系分析。生产者消费者是互斥关系，同时它们也是相互协作的关系，只有生产者生产了，消费者才能消费，它们也是同步关系。 整理思路。只有生产者和消费者两个进程，正好这两个是互斥和同步的关系
生产者与消费者问题C语言实现
热门推荐
徐奕的专栏
05-27 11万+
实验目的 ①实现生产者—消费者问题的模拟，以便更好的理解此经典进程同步问题。生产者－消费者问题是典型的PV操作问题，假设系统中有一个比较大的缓冲池，生产者的任务是只要缓冲池未满就可以将生产出的产品放入其中，而消费者的任务是只要缓冲池未空就可以从缓冲池中拿走产品。缓冲池被占用时，任何进程都不能访问。 ②每一个生产者都要把自己生产的产品放入缓冲池，每个消费者从缓冲池中取走产品消费。在这种情况下，生...
此程序是否线程安全 一个线程生产者 另一个线程消费者 采用一个循环队列
u012350025的博客
03-15 174
此程序是否线程安全 一个线程生产者 另一个线程消费者 采用一个循环队列 #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;string.h&amp;gt; #include &amp;lt;pthread.h&amp;gt; #define BUF_LEN (1024 * 1024 * 1024) #define OK 0 #define ERROR -1
Java——生产者-消费者问题
12-21
"生产者-消费者"问题是一个经典的多线程同步问题，主要涉及到进程间的协作与资源的共享。在这个问题中，生产者线程负责生产产品并将它们放入一个有限大小的缓冲区，而消费者线程则从缓冲区取出产品进行消费。为了...
生产者-消费者问题的模拟实现（课设含源代码）.doc
03-03
生产者-消费者问题是操作系统中经典的进程同步问题，它模拟了实际生产环境中的资源分配与消耗。在这个问题中，生产者进程负责生成数据并放入有限大小的缓冲区，而消费者进程则从缓冲区取出数据进行消费。为了确保...
生产者-消费者问题.cpp
03-26
生产者——消费者问题实际上是相互合作进程关系的一种抽象。该类问题不允许消费者进程到一个空缓冲区中取产品，同时也不允许生产者进程到一个已满且还没被取走的缓冲区中投放产品。 使用一个数组来表示具有n个(0，1...
生产者-消费者.cpp
05-19
《操作系统》第四版，实验，使用P/V操作，实现多线程控制，实现生产者-消费者问题，生产者生产商品，消费者消费，使用了win32的一些函数
生产者与消费者的问题-操作系统课程设计报告书.doc
最新发布
12-01
生产者与消费者的问题-操作系统课程设计报告书.doc
操原上机作业（二）
yin__ren的博客
04-16 4586
一、实验目的： （1）理解操作系统线程的概念和应用编程过程； （2）理解线程的同步概念和编程； 二、实验内容： （1）在Ubantu 或Fedora 环境使用fork函数创建一对父子进程，分别输出各自的进程号和提示信息串。 相关参考： 由 fork 创建的新进程被称为子进程。该函数被调用一次，但返回两次。两次返回的区别是子进程的返回值是0，而父进程的返回值则是新进程（子进程）的进...
进程同步生产者-消费者问题C语言,经典进程同步问题 --- 生产者和消费者
weixin_36440319的博客
05-21 3317
问题描述:一组生产者进程和一组消费者进程共享一个初始为空、大小为 n 的缓冲区,只有缓冲区没满时,生产者才能把消息放入到缓冲区,否则必须等待;只有缓冲区不空时,消费者才能从中取出消息,否则必须等待。由于缓冲区是临界资源,它只允许一个生产者放入消息,或者一个消费者从中取出消息。分析:关系分析:生产者和消费者对缓冲区互斥访问是互斥关系,同时生产者和消费者又是一个相互协作的关系,只有生产者生产之后,消费...
进程同步——生产者与消费者问题
Daisy_G_Jasmine的博客
05-20 734
文章目录问题描述分析过程用AND信号解决生产者-消费者问题代码实现 此文章参考b站视频 BV1Xk4y1q7RK 问题描述 在同一个进程地址空间内执行两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品，然后释放缓冲区。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放一个空缓冲区。当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻挡，直到新的物品被生产出来。 分析 1.不能向满存 2.不能向空取 3.同一
Lua学习笔记
chuanguan1820的博客
06-19 408
[TOC] Lua学习笔记(整理的runoob加自己的见解) 注意事项 - Lua中变量没有预定义类型，每个变量可以包含任意类型的值，要用就直接赋值一种数据类型的值 - nil类型就nil一个值，表示变量是否被赋值，变量赋值成nil也表示删除变量 - 使用Type(xxx变量) 可以获取该变量...
操作系统-第六次实验
qq_45755193的博客
12-12 1165
实验5 生产者-消费者问题 一、实验内容 模拟操作系统中进程同步和互斥。 在Linux操作系统下用C实现经典同步问题：生产者—消费者，具体要求如下： (1)一个大小为10的缓冲区，初始状态为空。 (2)2个生产者，随机等待一段时间，往缓冲区中添加数据，若缓冲区已满，等待消费者取走数据之后再添加，重复10次。 (3)2个消费者，随机等待一段时间，从缓冲区中读取数据，若缓冲区为空，等待生产者添加数据之后再读取，重复10次。 二、实验目的 • 熟悉临界资源、信号量及PV操作的定义与物理意义 ...
生产者消费者C语言
qq_41681845的博客
04-30 4138
操作系统生产者消费者问题C语言 #include <stdio.h> #include <pthread.h> #include <windows.h> #define N 100 #define true 1 #define producerNum 15 #define consumerN...
计算机操作系统——进程同步实验之生产者和消费者问题
TTTSEP9TH2244的博客
01-17 5358
一、实验内容 1、模拟操作系统中进程同步和互斥； 2、实现生产者和消费者问题的算法实现； 二、实验目的 1、熟悉临界资源、信号量及PV操作的定义与物理意义； 2、了解进程通信的方法； 3、掌握进程互斥与进程同步的相关知识； 4、掌握用信号量机制解决进程之间的同步与互斥问题； 5、实现生产者－消费者问题，深刻理解进程同步问题； 三、实验题目 三个生产者向两个消费者提供消息，它们共享一个有界缓冲池，缓冲池有四个缓冲区，生产者向其中投放消息，消费者从中取得消息。假定这些生产者和消费者互相等效，只要缓冲池未满，生产
Windows下并发地画圆和画方
weixin_41423387的博客
04-20 1590
hust操作系统原理实验：4.5（实验目的：熟悉Window线程创建过程）在windows环境下，利用高级语言编程环境（限定为VS环境或VC环境）调用CreateThread函数实现“并发地画圆和画方”。圆的中心，半径，颜色，正方形的中心，边长，颜色等参数自己确定，合适就行。圆和正方形的边界上建议取720个点。为直观展示绘制的过程，每个点绘制后睡眠0.2秒~0.5秒。 c++本身没有绘图的...
推选文档操作系统教程-南通大学PPT.ppt
10-27
著名的生产者--消费者问题是计算机操作系统中并发进程内在关系的一种抽象，是典型的进程同步问题。在操作系统中，生产者进程可以是计算进程、发送进程；而消费者进程可以是打印进程、接收进程等等。解决好生产者--...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值