《操作系统实验》C++实现生产者-消费者问题

电玩女神 2023-01-04 13:23 150阅读 0赞

### 生产者-消费者问题 ###

*  1 实验内容及要求
 *  2 实验环境
 *  3 实验设计
 *   *  3.1 问题描述
     *  3.2 基本思想
     *   *  3.2.1 生产者线程
         *  3.2.2 消费者线程
         *  3.2.3 同步的实现
     *  3.3 数据结构
 *  4 实验源码
 *  5 实验结果
 *  6 实验总结

# 1 实验内容及要求 #

1、模拟生产者—消费者问题；  
2、程序要添加适当的注释，程序的书写要采用缩进格式；  
3、程序要具在一定的健壮性，即当输入数据非法时，程序也能适当地做出反应；  
4、程序要做到界面友好，在程序运行时用户可以根据相应的提示信息进行操作。

# 2 实验环境 #

windows 10,Visual Studio 2019

# 3 实验设计 #

## 3.1 问题描述 ##

假设生产者和消费者线程共享一个大小为5的缓冲区。生产者生成新的数字，插入到缓冲区中；消费者不断从缓冲区中取出这些数字。只有缓冲区没满时，生产者才能把消息放入缓冲区，否则必须等待；只有缓冲区不空时，消费者才能从中取出消息，否则必须等待。

生产者

缓冲区

消费者

## 3.2 基本思想 ##

### 3.2.1 生产者线程 ###

生产者随机生产20个数据放入缓冲区。具体流程如下：

通过随机数生产数据

获取空缓冲区单元

互斥信号量上锁

将数据放入缓冲区

释放互斥信号量

满缓冲区数加1

### 3.2.2 消费者线程 ###

从缓冲区中取出20个数据。具体流程如下：

获取满缓冲区单元

互斥信号量上锁

从缓冲区取出数据

释放互斥信号量

空缓冲区数加1

### 3.2.3 同步的实现 ###

C++11中引入的用于多线程操作的thread类，以及线程互斥对象mutex，分别包含在头文件thread和mutex中，可以使生产者和消费者线程同步进行。

## 3.3 数据结构 ##

定义一个类sbuf，用来构造生产者-消费者程序：

class sbuf {
        
    private:
    	int buffer[5];  //缓冲区大小为5
    	int rear;       //指向数组最后一个元素
    	mutex mu;       //互斥信号量
    	int empty;      //空位数
    	int full;       //满位数
    public:
    	void init();            //初始化
    	void insert(int item);  //生产者像缓冲区放入产品
    	void remove();          //消费者从缓冲区取出产品
    	void display();         //显示缓冲区
    };

在类中定义了大小为5的数组作为缓冲区，以及同步信号量empty/full和互斥信号量mu。

# 4 实验源码 #

1.sbuf.h

#include<iostream>
    #include <Windows.h>
    #include<mutex>
    
    using namespace std;
    
    class sbuf {
        
    private:
    	int buffer[5];  //缓冲区大小为5
    	int rear;       //指向数组最后一个元素
    	mutex mu;       //互斥信号量
    	int empty;      //记录空位
    	int full;       //记录占位
    public:
    	void init();            //初始化
    	void insert(int item);  //放入产品
    	void remove();          //取出产品
    	void display();         //显示缓冲区
    };
    
    //初始化
    void sbuf::init() {
        
    	rear = -1;
    	empty = 5;
    	full = 0;
    }
    
    //放入产品
    void sbuf::insert(int item) {
        
    	while (1) {
        
    		while (!empty) {
        }
    		empty -= 1;             //P(empty)
    		mu.lock();              //P(mutex)
    		cout << "生产的数为:" << item << endl;
    	    buffer[++rear] = item;  //产品放入缓冲区
    		display();
    	    mu.unlock();            //V(mutex)
    	    full += 1;              //V(full)
    		break;
    	}
    }
    
    //取出产品
    void sbuf::remove() {
        
    	int item;
    	while (1) {
        
    		while (!full) {
        }
    		full -= 1;              //P(full)
    		mu.lock();              //P(mutex) 
    		item=buffer[rear--];    //从缓冲区取出产品
    		cout << "消费的数为:" << item << endl;
    		display();
    		mu.unlock();            //V(mutex)
    		empty += 1;             //V(empty)
    		break;
    	}
    }
    
    //显示缓冲区
    void sbuf::display() {
        
    	cout << "缓冲区:";
    	if (rear == -1)
    		cout << "空" << endl;
    	else {
        
    		for (int i = 0; i <= rear; i++)
    			cout << buffer[i]<<" ";
    		cout << endl;
    	}
    	cout << endl;
    }

2.exp1.cpp

#include"sbuf.h"
    #include<iostream>
    #include<random>
    #include <time.h>
    #include<thread>
    #include <Windows.h>
    
    using namespace std;
    
    //生产者线程
    void producer(sbuf* p) {
          
        int item;
        uniform_int_distribution<unsigned> k(500, 1500);
        static uniform_int_distribution<unsigned> u(1, 100);
        static default_random_engine e(time(0));  //随机数引擎
        for (int i = 0; i < 20; i++) {
             //生产20次
            item = u(e);
            p->insert(item);
            Sleep(k(e));
        }
    }
    
    //消费者线程
    void consumer(sbuf* p) {
        
        uniform_int_distribution<unsigned> k(1000, 2000);
        default_random_engine v(time(0));    //随机数引擎
        for (int i = 0; i < 20; i++) {
             //消费20次
            p->remove();
            Sleep(k(v));
        }
    }
    
    int main() {
        
        sbuf p;
        p.init();
    
        thread pro(producer, &p);    //创建生产者子线程
        thread con(consumer, &p);    //创建消费者子线程
        pro.join();                  //阻塞主线程
        con.join();                  //阻塞主线程
    
        cout << "结束！" << endl;
        
        return 0;
    }

# 5 实验结果 #

实验结果截取一部分如下：  
![实验结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE5Nzc0OQ_size_16_color_FFFFFF_t_70]

# 6 实验总结 #

通过本次实验，我对生产者-消费者问题的相关知识有了更加深刻的理解，进一步掌握了进程的同步的相关概念，理解了利用信号量机制解决进程同步问题的基本方法。并且初步掌握了利用C++11中std::thread类多线程编程。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDE5Nzc0OQ_size_16_color_FFFFFF_t_70]: /images/20221119/4d4783928ebc42e4815dc4d97b27f255.png