C++11 單生產者多消費者模式

2、單生產者多消費者模式：

• 與單生產者和單消費者模型不同的是，單生產者-多消費者模型中可以允許多個消費者同時從產品庫中取走產品。所以除了保護產品庫在多個讀寫線程下互斥之外，還需要維護消費者取走產品的計數器，代碼如下:
• 在多個消費者消費的情況下，我們要確保消費的個數不要超過倉庫生產的個數，多個消費要確保消費計數器的互斥

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <deque>
using namespace std;

static const int kItemsToProduce = 20;//定義生產者能夠生產的最大產品個數
std::mutex stdoutMutex;//多線程標準輸出 同步鎖

struct ItemRepository
{
    deque<int> itemQueue;   // 這裏用隊列代表倉庫緩衝區
    int MaxSize = 10;       // 倉庫所容納的產品最大個數
    int itemCounter=0;
    std::mutex mtx;         // 互斥量,保護產品緩衝區
    std::mutex itemCounterMtx;
    std::condition_variable repository_notFull;     // 條件變量, 指產品倉庫緩衝區不爲滿
    std::condition_variable repository_notEmpty;    // 條件變量, 指產品倉庫緩衝區不爲空
}gItemRepository;   // 產品庫全局變量，生產者和消費者操作該變量.

typedef struct ItemRepository ItemRepository;


// 生產 產品
void ProduceItem(ItemRepository &itemRepo, int item)
{
    std::unique_lock<std::mutex> lock(itemRepo.mtx);
    itemRepo.repository_notFull.wait(lock, [&itemRepo] {
        bool full = itemRepo.itemQueue.size() >= itemRepo.MaxSize;
        if (full)
        {
            std::lock_guard<std::mutex> lock(stdoutMutex);
            cout << "倉庫滿了,生產者等待中..." << "thread id = " << std::this_thread::get_id() << endl;
        }
        return !full;
    });

    itemRepo.itemQueue.push_back(item);         // 倉庫放入產品
    itemRepo.repository_notEmpty.notify_all();  // 通知消費者倉庫不爲空
    lock.unlock();  // 釋放鎖
}

// 消費 產品
int ConsumeItem(ItemRepository &itemRepo)
{
    int data;
    std::unique_lock<std::mutex> lock(itemRepo.mtx);

    // 等待信號不爲空的通知，wait 第二參數爲true時 向下執行，否則一直等待
    itemRepo.repository_notEmpty.wait(lock, [&itemRepo] {
        bool empty = itemRepo.itemQueue.empty();
        if (empty)
        {
            std::lock_guard<std::mutex> lock(stdoutMutex);
            cout << "倉庫空了,消費者等待中..." << "thread id = " << std::this_thread::get_id() << endl;
        }

        return !empty;
    });

    data = itemRepo.itemQueue.front();
    itemRepo.itemQueue.pop_front();
    itemRepo.repository_notFull.notify_all();
    lock.unlock();
    return data;
}

// 生產者任務
void ProducerTask()
{
    for (int i = 1;i <= kItemsToProduce;++i)
    {
        ProduceItem(gItemRepository, i);    // 生產產品
        {
            std::lock_guard<std::mutex> lock(stdoutMutex);
            cout << "Produce the " << i << " ^th item..." << endl;
        }
    }
    {
        std::lock_guard<std::mutex> lock(stdoutMutex);
        cout << "Producer Thread exit.... " << endl;
    }
}

// 消費者任務
void ConsumerTask(int th_ID)
{
    bool readyToExit = false;
    while (true)
    {
        this_thread::sleep_for(std::chrono::seconds(1));
        std::unique_lock<std::mutex> lock(gItemRepository.itemCounterMtx);  // 倉庫產品消費計數器保持多線程互斥
        if (gItemRepository.itemCounter < kItemsToProduce)
        {
            int item = ConsumeItem(gItemRepository);    // 消費產品
            gItemRepository.itemCounter++;  // 每消費一次進行計數器+1
            {
                std::lock_guard<std::mutex> lock(stdoutMutex);
                cout << "Consume Thread " <<th_ID<<" the " <<item << "^th item..." << endl;
            }
        }
        else
        {
            readyToExit = true;
        }
        lock.unlock();
        if (readyToExit)
            break;
    }
    {
        std::lock_guard<std::mutex> lock(stdoutMutex);
        cout << "Consumer Thread "<<th_ID<<" exit...." << endl;
    }
}

int main()
{
    std::thread producer(ProducerTask);
    std::thread consumer1(ConsumerTask,1);
    std::thread consumer2(ConsumerTask,2);
    std::thread consumer3(ConsumerTask,3);
    std::thread consumer4(ConsumerTask,4);

    producer.join();
    consumer1.join();
    consumer2.join();
    consumer3.join();
    consumer4.join();

    system("pause");
    return 0;
}

Produce the 1 ^th item...
Produce the 2 ^th item...
Produce the 3 ^th item...
Produce the 4 ^th item...
Produce the 5 ^th item...
Produce the 6 ^th item...
Produce the 7 ^th item...
Produce the 8 ^th item...
Produce the 9 ^th item...
Produce the 10 ^th item...
倉庫滿了,生產者等待中...thread id = 140649595565824
Consume Thread 1 the 1^th item...
Produce the 11 ^th item...
倉庫滿了,生產者等待中...thread id = 140649595565824
Consume Thread 2 the 2^th item...
Consume Thread 4 the 3^th item...
Consume Thread 3 the 4^th item...
Produce the 12 ^th item...
Produce the 13 ^th item...
Produce the 14 ^th item...
倉庫滿了,生產者等待中...thread id = 140649595565824
Consume Thread 1 the 5^th item...
Produce the 15 ^th item...
倉庫滿了,生產者等待中...thread id = 140649595565824
Consume Thread 2 the 6^th item...
Consume Thread 4 the 7^th item...
Consume Thread 3 the 8^th item...
Produce the 16 ^th item...
Produce the 17 ^th item...
Produce the 18 ^th item...
倉庫滿了,生產者等待中...thread id = 140649595565824
Consume Thread 1 the 9^th item...
Produce the 19 ^th item...
倉庫滿了,生產者等待中...thread id = 140649595565824
Consume Thread 2 the 10^th item...
Consume Thread 4 the 11^th item...
Consume Thread 3 the 12^th item...
Produce the 20 ^th item...
Producer Thread exit.... 
Consume Thread 1 the 13^th item...
Consume Thread 2 the 14^th item...
Consume Thread 4 the 15^th item...
Consume Thread 3 the 16^th item...
Consume Thread 1 the 17^th item...
Consume Thread 2 the 18^th item...
Consume Thread 4 the 19^th item...
Consume Thread 3 the 20^th item...
Consumer Thread 1 exit....
Consumer Thread 2 exit....
Consumer Thread 4 exit....
Consumer Thread 3 exit....

real    0m6.067s
user    0m0.004s
sys 0m0.052s

g++ main2.cpp -std=c++11 -lpthread
time ./a.out > my.log