生产者、消费者模式

是什么

生产者消费者模式（生产者消费者模式）是经典的线程同步案例，也称为有限缓冲问题。
生产者产生数据，但是数据不能超出缓冲区的限制，当缓冲区满时，停止生产。
消费者消费生产者产生的数据，当缓冲区为空时，停止消费。

能干什么

生产者消费者模式时一种设计思想，并不是一种固定的写法。就像23种设计模式一样，它所传递的解决问题的思路（思想、思维）。

例如，消息队列。消息队列就使用了生产者消费者模式的思想，
线程A（或系统A，生产者）产生消息，将消息入队，其他的线程（消费者）从消息队列中取出消息，并响应。

怎么干

为了方便展示生产者和消费之间的关系，特将队列换成栈去实现，因为入栈和出栈在同一端完成，可以根据出栈的顺序观察到生产者和消费者之间的关系。
以函数指针来表示一种消息。

std::stack<int (*)(const int x)> product_stk;

生产者pdoductor_fun的实现，在进入临界区时加锁，当栈（缓冲区）等于栈的预设大小时阻塞当前线程，wait等待消费者唤醒；否则生产消息，notify_all通知消费者可以消费。
用随机数表示产生的不同的消息（调用不同的函数）

void pdoductor_fun() {
    srand(time(NULL));
    while (1) {
        {
            std::unique_lock<std::mutex> ulk(mtx);
            while (product_stk.size() >= 20) {
                cond_full_var.wait(ulk);
            }
            if (rand() % 2 == 1) {
                product_stk.push(foo1);
            } else {
                product_stk.push(foo2);
            }
            ++global_num;
            cond_null_var.notify_all();
            std::cout << product_stk.size() << std::endl;
        }
        sleep(1);
    }
    return;
}

消费者cunsumer_fun当栈（缓冲区）空时，wait阻塞消费者线程，等待生产者唤醒；否则，取出栈中的消息，notify_all通知生产者可以生产。

void cunsumer_fun() {
    int (*ptr_fun)(const int x);
    int x;
    while (1) {
        {
            std::unique_lock<std::mutex> ulk(mtx);
            // lock_guard<std::mutex> lg(m);
            while (product_stk.empty()) {
                cond_null_var.wait(ulk);
            }
            x = global_num;
            ptr_fun = product_stk.top();
            product_stk.pop();
            cond_full_var.notify_all();
        }
        ptr_fun(x);
        sleep(3);
    }
    return;
}

完整代码如下，用sleep来控制消息产生的速度和消费的速度。虽然示例程序中有一个生产者、两个消费者，但消息产生的速度仍大于消费，可以观察出当栈满时消息不在产生。
注：linux下sleep的单位是秒s，windows下sleep的单位时毫秒ms。

#include <iostream>
#include <condition_variable>
#include <thread>
// #include <queue>
#include <stack>
#include <stdlib.h>
#include <unistd.h>
#include <mutex>

using namespace std;

int foo1(const int x);
int foo2(const int x);
void pdoductor_fun();
void cunsumer_fun();

const int STK_MAX_SIZE = 20;
std::stack<int (*)(const int x)> product_stk;
mutex mtx;
int global_num = 0;
std::condition_variable cond_null_var, cond_full_var;

int main() {

    std::thread productor_thread(pdoductor_fun);

    // std::cout << productor_thread.get_id() << std::endl;

    std::thread consumer_thread_1(cunsumer_fun);
    std::thread consumer_thread_2(cunsumer_fun);

    consumer_thread_1.join();
    consumer_thread_2.join();
    productor_thread.join();
    return 0;
}

void cunsumer_fun() {
    int (*ptr_fun)(const int x);
    int x;
    while (1) {
        {
            std::unique_lock<std::mutex> ulk(mtx);
            // lock_guard<std::mutex> lg(m);
            while (product_stk.empty()) {
                cond_null_var.wait(ulk);
            }
            x = global_num;
            ptr_fun = product_stk.top();
            product_stk.pop();
            cond_full_var.notify_all();
        }
        ptr_fun(x);
        sleep(3);
    }
    return;
}

void pdoductor_fun() {
    srand(time(NULL));
    while (1) {
        {
            std::unique_lock<std::mutex> ulk(mtx);
            while (product_stk.size() >= 20) {
                cond_full_var.wait(ulk);
            }
            if (rand() % 2 == 1) {
                product_stk.push(foo1);
            } else {
                product_stk.push(foo2);
            }
            ++global_num;
            cond_null_var.notify_all();
            std::cout << product_stk.size() << std::endl;
        }
        sleep(1);
    }
    return;
}

int foo1(const int x) {
    std::cout << "foo1 " << x << std::endl;
    return 1;
}

int foo2(const int x) {
    std::cout << "foo2 " << -x << std::endl;
    return 2;
}

cmake版本 3.16，源代码文件放在项目目录src文件夹下。CMakeLists.txt如下

cmake_minimum_required(VERSION 3.16)

project(product_consumer)

set(CXX_STANDARD c++11)
set(CMAKE_CXX_STANDARD_REQUIRED True)

# set(THREADS_PREFER_PTHREAD_FLAG ON)

find_package(Threads)

file(GLOB SRC_CC ${PROJECT_SOURCE_DIR}/src/*.cc)
file(GLOB SRC_H ${PROJECT_SOURCE_DIR}/src/*.h)

add_executable(product_consumer ${SRC_CC} ${SRC_H})

target_link_libraries(product_consumer PUBLIC ${CMAKE_THREAD_LIBS_INIT})

写在最后，是关于函数指针的问题。
假设有函数指针

int (*ptr_foo)();

在c中，ptr_foo既可以指向，返回值为int有参的函数，也可以指向返回值int无参的函数。

int foo1() { return 0; }
int foo2(const int x) { return 0; }
int foo3(const int x， char c) { return 0; }

ptr_foo = foo1;  // 正确
ptr_foo = foo1;  // 正确
ptr_foo = foo1;  // 正确

只能指向无参的函数指针应该这样写

int (*ptr_foo)(void);

而在c++中函数指针的参数列表需要和函数的参数列表相匹配