生产者消费者问题算法的实现

目录

一、实验内容

        1.问题描述：

        2.功能要求：

二、背景

三、思路

   1.生产者：

            2.消费者：

四、核心代码

五、运行结果

 六、结论

---

一、实验内容

        1.问题描述：

        一组生产者向一组消费者提供消息，它们共享一个有界缓冲池，生产者向其中投放消息，消费者从中取得消息。假定这些生产者和消费者互相等效，只要缓冲池未满，生产者可将消息送入缓冲池,只要缓冲池未空，消费者可从缓冲池取走一个消息。

        2.功能要求：

        根据进程同步机制，编写一个解决上述问题的程序，可显示缓冲池状态、放数据、取数据等过程。

二、背景

        生产者消费者问题，也称有限缓冲问题，是一个多线程同步问题的经典案例。该问题描述了共享固定大小缓冲区的两个线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。

三、思路

   1.生产者：

// 生产者生产产品并放入缓冲区
void Produce(Item* ir, int item)
{
    std::unique_lock<std::mutex> lock(ir->mtx);        // 借助互斥信号量 mutex去申请使用缓冲区
    while (((ir->write + 1) % ItemSize) == ir->read)   // 缓冲池满，等待
    {
        std::cout << "\n生产者 等待缓冲区清空..." << std::endl;
        (ir->not_full).wait(lock);
    }

    (ir->buffer)[ir->write] = item;// 往缓冲区放入一个产品item
    (ir->write)++;                 // 写指针后移

    if (ir->write == ItemSize)     // 当前已到缓冲区尾端，则回到队首
    {
        ir->write = 0;
    }

    (ir->not_empty).notify_all();  // 通知消费者产品库不为空
    lock.unlock();                 // 释放缓冲区对应的mutex
}

   2.消费者：

//消费者消费产品
int Consumer(Item* ir)
{
    int data;
    std::unique_lock<std::mutex> lock(ir->mtx);        // 准备修改缓冲区大小，互斥过程通过mutex信号量实现

    while (ir->write == ir->read)        // 缓冲池空，等待
    {
        std::cout << "\n消费者 等待产品生产..." << std::endl;
        (ir->not_empty).wait(lock);      // 消费者等待"缓冲区不为空"这一条件发生.
    }

    data = (ir->buffer)[ir->read];       // 从缓冲区获取一个产品
    (ir->read)++;                        // 读位置后移

    if (ir->read == ItemSize)    // 当前已到缓冲区尾端，则回到队首
        ir->read = 0;

    (ir->not_full).notify_all(); // 通知生产者缓冲区不为满
    lock.unlock();               // 解锁mtx

    return data;                 // 返回产品.
}

四、核心代码

#include <cstdlib>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
//#include <unistd.h>
using namespace std;
// N个生产者，N个消费者

static const int ItemSize = 4;      // 缓冲区大小
static int ItemsPro = 1;            //已生产的产品的数量
static const int ItemsProMAX = 20;  // 生产者生产的产品的上限（生产了ItemsProMAX个产品后，整个程序就停止）

struct Item                    // 定义数据结构
{
    int buffer[ItemSize];      // 缓冲区数组
    size_t read;               // 循环缓冲区的读下标索引
    size_t write;              // 循环缓冲区的写下标索引
    size_t counter;            // 当前产品的数量

    std::mutex mtx;            // 对缓冲区的互斥使用，所定义的信号量
    std::mutex countermtx;     // 对当前产品数量counter这个变量值的互斥更改

    std::condition_variable not_full;     // 条件变量：指示非空缓冲区（即产品数量）的大小
    std::condition_variable not_empty;    // 条件变量：指示空缓冲区的大小
} gItem;

typedef struct Item Item;  // 重命名

// 生产者生产产品并放入缓冲区
void Produce(Item* ir, int item)
{
    std::unique_lock<std::mutex> lock(ir->mtx);        // 借助互斥信号量 mutex去申请使用缓冲区
    while (((ir->write + 1) % ItemSize) == ir->read)   // 缓冲池满，等待
    {
        std::cout << "\n生产者 等待缓冲区清空..." << std::endl;
        (ir->not_full).wait(lock);
    }

    (ir->buffer)[ir->write] = item;// 往缓冲区放入一个产品item
    (ir->write)++;                 // 写指针后移

    if (ir->write == ItemSize)     // 当前已到缓冲区尾端，则回到队首
    {
        ir->write = 0;
    }

    (ir->not_empty).notify_all();  // 通知消费者产品库不为空
    lock.unlock();                 // 释放缓冲区对应的mutex
}

//消费者消费产品
int Consumer(Item* ir)
{
    int data;
    std::unique_lock<std::mutex> lock(ir->mtx);        // 准备修改缓冲区大小，互斥过程通过mutex信号量实现

    while (ir->write == ir->read)        // 缓冲池空，等待
    {
        std::cout << "\n消费者 等待产品生产..." << std::endl;
        (ir->not_empty).wait(lock);      // 消费者等待"缓冲区不为空"这一条件发生.
    }

    data = (ir->buffer)[ir->read];       // 从缓冲区获取一个产品
    (ir->read)++;                        // 读位置后移

    if (ir->read == ItemSize)    // 当前已到缓冲区尾端，则回到队首
        ir->read = 0;

    (ir->not_full).notify_all(); // 通知生产者缓冲区不为满
    lock.unlock();               // 解锁mtx

    return data;                 // 返回产品.
}


//生产者任务  不断生产产品，直到规定的产品数量 
void ProducerTask()
{
    for (; ItemsPro <= ItemsProMAX; ++ItemsPro)
    {
        // sleep(1);
        std::cout << "\n生产者线程 " << std::this_thread::get_id()
            << " 生产第 " << ItemsPro << "个产品..." << std::endl;
        Produce(&gItem, ItemsPro); // 循环生产 ItemsProMAX 个产品.
    }
    std::cout << "\n生产者线程 " << std::this_thread::get_id() << " 结束..." << std::endl;
}

//消费者任务  不断消费产品，直到产品无
void ConsumerTask()
{
    bool exit = false;
    while (1) {
        // sleep(1);
        std::unique_lock<std::mutex> lock(gItem.countermtx); // 准备要修改counter, 对他进行互斥修改。
        if (gItem.counter <= ItemsProMAX) { // 当前产品数量少于生产产品数量的上限
            int item = Consumer(&gItem);    // 消费
            ++(gItem.counter);
            std::cout << "\n消费者线程 " << std::this_thread::get_id() << " "
                << "正在消费第 " << item << "个产品" << std::endl;
        }
        else exit = true;                          // 如果当前产品数量已达上限，则退出。
        lock.unlock();
        if (exit == true) break;
    }
    std::cout << "\n消费者线程 " << std::this_thread::get_id() << " 结束..." << std::endl;
}

void Init_ItemRepository(Item* ir)
{
    ir->write = 0;  // 初始化产品写入位置
    ir->read = 0;   // 初始化产品读取位置
    ir->counter = 0;// 计算当前产品数量
}

int main()
{
    Init_ItemRepository(&gItem);
    std::thread producer1(ProducerTask);   // 创建线程 > 生产者1号
    std::thread producer2(ProducerTask);   // 创建线程 > 生产者2号
    std::thread consumer1(ConsumerTask);   // 创建线程 > 消费者1号
    std::thread consumer2(ConsumerTask);   // 创建线程 > 消费者2号
    std::thread consumer3(ConsumerTask);   // 创建线程 > 消费者3号

    producer1.join();      // 加入线程运行队列
    producer2.join();      // 加入线程运行队列
    consumer1.join();      // 加入线程运行队列
    consumer2.join();      // 加入线程运行队列
    consumer3.join();      // 加入线程运行队列

}

五、运行结果

 

 六、结论

        生产者和消费者问题从单个到多个，从同步问题到互斥问题，只有真正分析清楚他们之间的同步互斥变量，才能做到不放生死锁，本文首先通过对问题的分析，抽象出同步变量、互斥变量，再进行操作，使问题得到解决，并对其中所提问题做出解释。