#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<stdio.h>
#include<vector>
using namespace std;

#define NUM 5

pthread_mutex_t mutx = PTHREAD_MUTEX_INITIALIZER;//构建一个全局锁
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;//构建一个全局条件变量
int tickets = 10;

class pthread_data
{
public:
    pthread_t tid;
    char buffer[64];
};

void* start_routine(void* args)
{
    pthread_data* p = (pthread_data*)args;
    string s;
    s += p->buffer;
    s += "Remaining tickets:";
    while(1)
    {
        pthread_mutex_lock(&mutx);//加锁
        pthread_cond_wait(&cond, &mutx);//线程进入等待队列
        if(tickets > 0)
        {
            --tickets;
            pthread_mutex_unlock(&mutx);//解锁
            printf("%s%d\n", s.c_str(), tickets);//不修改临界资源，可以不包含在内
        }
        else
        {
            pthread_mutex_unlock(&mutx);//解锁
            break;
        }
    }
    pthread_exit(nullptr);
}

int main()
{
    vector<pthread_data*> vpd;
    //创建多个线程
    for(int i = 0; i<NUM; ++i)
    {
        pthread_data* pd = new pthread_data;
        snprintf(pd->buffer, sizeof(pd->buffer), "thread%d buy ticket:",i+1);
        pthread_create(&(pd->tid), nullptr, start_routine, (void*)pd);
        vpd.push_back(pd);
    }
    //主线程唤醒其他线程
    for(;;)
    {
        sleep(1);
        pthread_cond_signal(&cond);
        printf("main thread wake up a thread\n");
    }
    //线程回收
    for(int i = 0; i<NUM; ++i)
    {
        pthread_join(vpd[i]->tid, nullptr);
        delete vpd[i];
    }
    return 0;
}

条件变量、票数和锁都是全局变量，每个线程申请锁成功就进入条件变量等待队列。主线程每个一秒钟唤醒一个等待的线程抢票。

运行结果：

可以发现线程按12345的顺序循环抢票。

使用pthread_cond_broadcast()接口可以一次唤醒条件变量等待队列中的的所有线程，每隔一秒唤醒一次。

运行结果：

仍然是按照一定顺序抢票，只是进行抢票的线程是5个同时进行。

三、基于阻塞队列的生产消费模型

既然讲了这么半天的生产消费模型，那我们不妨实现一个。

1.阻塞队列类

首先需要搭建模型的框架，也就是实现包括生产者线程、消费者线程，还有一个储存数据的阻塞队列（缓冲区）的简单执行代码。

（1）阻塞队列

阻塞队列的实现有以下注意事项：

阻塞队列可使用C++STL中的queue实现。

由于阻塞队列是公共资源，所以必须保证它是线程安全的。生产者线程和消费者线程需要互斥访问，其实也只需要一把互斥锁就能实现生产者和消费者间的互斥。以后的生产者和生产者，消费者和消费者之间的互斥也是这样实现的。

只有阻塞队列中有数据消费者才能读取，消费者读取时，生产者不能生产，必须在等待队列中。

阻塞队列中没有数据或者数据未填满时，生产者才能生产，消费者在生产的时候，消费者不能读取，必须在等待队列中。

cpp 复制代码

template<claas T>
class Blockqueue
{
public:
    //构造函数
    Blockqueue(size_t capcity = MAX_NUM)
        :_capcity(capcity)
    {
        pthread_mutex_init(&_mutx, nullptr);
        pthread_cond_init(&_pcond, nullptr);
        pthread_cond_init(&_ccond, nullptr);
    }

    //析构函数
    ~Blockqueue()
    {
        pthread_mutex_destroy(&_mutx);
        pthread_cond_destroy(&_pcond);
        pthread_cond_destroy(&_ccond);
    }

    //生产数据
    void push(const T& data);
    //消费数据
    void pop(T* data);
private:
    //检测队列是否装满
    size_t Isfull() const
    {
        return (_q.size() == _capcity);
    }

    std::queue<T> _q;
    pthread_mutex_t _mutx;
    pthread_cond_t _pcond;
    pthread_cond_t _ccond;
    size_t _capcity;
};

为了保持生产者和消费者的互斥，我们对生产者和消费者各使用一个条件变量，用一个锁控制对阻塞队列的访问。

需要给阻塞队列储存的数据量设置一个上限，生产者线程不能无限制地生产数据。

构造函数中初始化锁和条件变量，在析构函数中释放互斥锁和条件变量。阻塞队列的容量设置一个合适的缺省值。

（2）实现生产者的生产函数

生产数据我们一般使用push作为函数名。

cpp 复制代码

void push(const T& data)
{
    //下面的判断就开始使用共享资源，需要加锁
    pthread_mutex_lock(&_mutx);
       
    //如果当前队列是满的，那就需要将生产者线程加入等待队列挂起
    if(Isfull())
    {
        pthread_cond_wait(&_pcond, &_mutx)
    }
    _q.push(data);
    //唤醒消费者线程消费
    pthread_cond_signal(&_ccond, &_mutx);
    //解锁
    pthread_mutex_unlock(&_mutx);
}

生产者线程调用生产数据接口时，先申请锁进入临界区。

当阻塞队列满时，在生产者条件变量将线程放入等待队列中挂起。

当阻塞队列不满时，生产者生产数据到阻塞队列，由于消费者线程全部在等待，所以需要唤醒消费者线程消费数据，否则生产者会一直生产至满。

（3）实现消费者的消费函数

消费数据我们一般使用pop作为函数名。

cpp 复制代码

void pop(T* data)
{
    //下面的判断就开始使用共享资源，需要加锁
    pthread_mutex_lock(&_mutx);
    //如果当前队列是空的，那就需要将消费者线程加入等待队列挂起
    if(_q.empty())
    {
        pthread_cond_wait(&_ccond, &_mutx)
    }
    //将数据输出到data中并删除
    *data = _q.front();
    _q.pop();
    //唤醒生产者线程生产
    pthread_cond_signal(&_pcond, &_mutx);
    //解锁
    pthread_mutex_unlock(&_mutx);
}

消费者线程同样先申请到锁后进入临界区。

当阻塞队列为空时，没有数据可以消费，消费者挂起等待。

当阻塞队列为不为空时，消费者消费数据，由生产者线程全部在等待，所以需要唤醒生产者线程消费数据，否则消费者会一直消费至空。

2.pthread_cond_wait为什么要传入锁

使用pthread_cond_wait接口时，必须传如一个锁，这一点我们没有解释。

线程在条件变量的等待队列中排队等待，其目的就是要拿到要访问临界资源的那把锁，申请到锁，线程就可以进入临界区。

如果一个线程拿到了锁，而又发现自己不满足条件需要挂起等待。按照之前的知识，该线程应该继续拿着锁进入条件变量的等待队列。即使其他线程被唤醒了，因为申请不到到锁，无法访问共享资源，只能被挂起。

为了解决这个问题，pthread_cond_wiat的实现大致分三个步骤：挂起该线程->释放锁->记录锁。

也就是说，只要是持有锁的线程进入等待队列，就自动释放自己持有的锁，而释放锁也是原子性操作，不会引起线程安全问题。

在最后，接口还会记录当前进程挂起时释放的锁，这也就解释了为什么唤醒线程的时候，pthread_cond_signal(pthread_cond_t* cond)只有一个参数，被唤醒线程根据记录就知道它该去申请哪把锁。

我们最终得到以下结论：

参数传递的这个锁必须是正在使用的锁。
调用pthread_cond_wait函数的进程，会以原子性的方式，将锁释放，并将自己挂起。
线程在被唤醒的时候，会自动重新获取挂起时传入的锁。

3.生产者和消费者线程的执行函数

（1）执行函数

生产者不断生成随机数再将数据插入阻塞队列。消费者不断将随机数再从阻塞队列中拿出来。

cpp 复制代码

//生产者
void* Produce(void* args)
{
    Blockqueue<int>* bq = (Blockqueue<int>*)args;
    while(1)
    {
        sleep(1);
        int data = rand()%10;
        bq->push(data);
        printf("生产数据完成，数据为：%d\n", data);
    }
    return nullptr;
}

//消费者
void* Consume(void* args)
{
    Blockqueue<int>* bq = (Blockqueue<int>*)args;
    while(1)
    {
        sleep(1);
        int data = 0;
        bq->pop(&data);
        printf("消费数据完成，数据为：%d\n", data);
    }
    return nullptr;
}

（2）试运行

我们只创建一个生产者线程和一个消费者线程，并且让生产者每一秒生产一个数据，所以最终代码如下：

cpp 复制代码

#include<iostream>
#include<queue>
#include<stdlib.h>
#include<time.h>
#include<unistd.h>
using namespace std;

#define MAX_NUM 10

template<class T>
class Blockqueue
{
public:
    //构造函数
    Blockqueue(size_t capcity = MAX_NUM)
        :_capcity(capcity)
    {
        pthread_mutex_init(&_mutx, nullptr);
        pthread_cond_init(&_pcond, nullptr);
        pthread_cond_init(&_ccond, nullptr);
    }

    //析构函数
    ~Blockqueue()
    {
        pthread_mutex_destroy(&_mutx);
        pthread_cond_destroy(&_pcond);
        pthread_cond_destroy(&_ccond);
    }

    //生产数据
    void push(const T& data)
    {
        //下面的判断就开始使用共享资源，需要加锁
        pthread_mutex_lock(&_mutx);
        //如果当前队列是满的，那就需要将生产者线程加入等待队列挂起
        if(Isfull())
        {
            pthread_cond_wait(&_pcond, &_mutx);
        }
        _q.push(data);
        //唤醒消费者线程消费
        pthread_cond_signal(&_ccond);
        //解锁
        pthread_mutex_unlock(&_mutx);
    }

    //消费数据
    void pop(T* data)
    {
        //下面的判断就开始使用共享资源，需要加锁
        pthread_mutex_lock(&_mutx);
        //如果当前队列是空的，那就需要将消费者线程加入等待队列挂起
        if(_q.empty())
        {
            pthread_cond_wait(&_ccond, &_mutx);
        }
        //将数据输出到data中并删除
        *data = _q.front();
        _q.pop();
        //唤醒生产者线程生产
        pthread_cond_signal(&_pcond);
        //解锁
        pthread_mutex_unlock(&_mutx);
    }

private:
    //检测队列是否装满
    size_t Isfull() const
    {
        return (_q.size() == _capcity);
    }

    std::queue<T> _q;
    pthread_mutex_t _mutx;
    pthread_cond_t _pcond;
    pthread_cond_t _ccond;
    size_t _capcity;
};

//生产者
void* Produce(void* args)
{
    Blockqueue<int>* bq = (Blockqueue<int>*)args;
    while(1)
    {
        sleep(1);
        int data = rand()%10;
        bq->push(data);
        printf("生产数据完成，数据为：%d\n", data);
    }
    return nullptr;
}

//消费者
void* Consume(void* args)
{
    Blockqueue<int>* bq = (Blockqueue<int>*)args;
    while(1)
    {
        //sleep(1);
        int data = 0;
        bq->pop(&data);
        printf("消费数据完成，数据为：%d\n", data);
    }
    return nullptr;
}

int main()
{
    srand((unsigned int)time(nullptr));
    Blockqueue<int>* bq = new Blockqueue<int>;

    pthread_t tids[2];

    pthread_create(&tids[0], nullptr, Produce, (void*)bq);
    pthread_create(&tids[1], nullptr, Consume, (void*)bq);

    pthread_join(tids[0], nullptr);
    pthread_join(tids[1], nullptr);

    return 0;
}

运行结果：

4.部分细节处理

对于一个消费者和一个生产者的模型而言，上面的代码的确足够了。但是生产消费模型的生产者和消费者都应当有多个，此时我们就需要对其进行修改。

（1）伪唤醒问题

如果现在有多个生产者线程在进行数据生产。当阻塞队列满了以后，所有生产者线程都会在条件变量的等待队列中等待。

第一种情况，某个生产者线程调用挂起接口失败。

pthread_cond_wait即使调用失败，它也只会返回错误码，并不能阻断执行流继续向下执行。所以，即使出错，生产者还是会生成数据到阻塞队列中。

第二种情况，一个消费者线程一次唤醒所有生产者线程。

比如，现在阻塞队列满了，消费者线程消费了一个数据并且唤醒了所有的生产者线程，那么很多个生产者向阻塞队列的一个空位置生成数据，同样会出现上述问题。

上面这种情况被叫做伪唤醒，再生产者和消费者线程中都存在这个问题。所以需要让执行流只要不满足队列满或空的条件就循环执行pthread_cond_wait。执行成功了，该线程就被挂起了，执行流不再运行；执行失败了，执行流会一直调用pthread_cond_wait，执行流也不会向下操作数据。

生产数据

消费数据

（2）解锁与唤醒的顺序

在生产者生产完数据后，它需要做两件事：唤醒消费者线程和归还锁。

对于消费者进程也是一样的：唤醒生产者线程和归还锁。

由于唤醒线程是不对共享资源进行操作的，所以对于唤醒线程和解锁的顺序谁先谁后都可以。只是更建议先唤醒再解锁。

5.处理任务的生产消费模型

（1）代码改造

我们使用生产消费模型可不是用来保存随机数的，而是用它处理任务的。

我们可以写一个保存计算方法的任务类，从而实现一个随机数计算器。

任务类

cpp 复制代码

//任务类
class Task
{
    typedef std::function<int(int,int,char)> func_t;
public:
    //默认构造
    Task()
    {}
    //构造函数
    Task(int a, int b, char op, func_t func)
        :_a(a)
        ,_b(b)
        ,_op(op)
        ,_func(func)
    {}

    //仿函数
    string operator()()
    {
        int result = _func(_a, _b, _op);
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "%d %c %d = %d\n", _a, _op, _b, result);
        string s(buffer);
        return s;
    }

    //显示任务
    string show_task()
    {
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "%d %c %d = ?\n", _a, _op, _b);
        string s(buffer);
        return s;
    }
private:
    func_t _func;
    int _a;
    int _b;
    char _op;
};

设置处理任务的函数，修改生产者和消费者线程执行的函数。

cpp 复制代码

//计算器函数
const string ops = "+-*/%";
int calculate(int a, int b, char op)
{
    int result = 0;
    switch(op)
    {
        case '+':
            result = a + b;
            break;
        case '-':
            result = a - b;
            break;
        case '*':
            result = a * b;
            break;
        case '/':
        {
            if(b == 0)
                cerr << "除数不能为0\n";
            else
                result = a / b;
        }
            break;
        case '%':
        {
            if(b == 0)
                cerr << "取模的数字不能为0\n";
            else
                result = a % b;
        }
            break;
        default:
            break;
    }
    return result;
}

//生产者
void* Produce(void* args)
{
    Blockqueue<Task>* bq = (Blockqueue<Task>*)args;
    while(1)
    {
        sleep(1);
        int a = rand()%10;
        int b = rand()%10;
        int opnum = rand()%ops.size();
        Task data(a, b, ops[opnum], calculate);
        string s = "数据生产完成，需要计算：";
        bq->push(data);
        s += data.show_task().c_str();
        cout << s;
    }
    return nullptr;
}

（2）运行

在主线程中多创建几个线程就可以运行了。

总代码如下：

cpp 复制代码

#include<iostream>
#include<queue>
#include<stdlib.h>
#include<time.h>
#include<unistd.h>
#include<functional>
using namespace std;

#define MAX_NUM 10

//任务类
class Task
{
    typedef std::function<int(int,int,char)> func_t;
public:
    //默认构造
    Task()
    {}
    //构造函数
    Task(int a, int b, char op, func_t func)
        :_a(a)
        ,_b(b)
        ,_op(op)
        ,_func(func)
    {}

    //仿函数
    string operator()()
    {
        int result = _func(_a, _b, _op);
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "%d %c %d = %d\n", _a, _op, _b, result);
        string s(buffer);
        return s;
    }

    //显示任务
    string show_task()
    {
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "%d %c %d = ?\n", _a, _op, _b);
        string s(buffer);
        return s;
    }
private:
    func_t _func;
    int _a;
    int _b;
    char _op;
};

template<class T>
class Blockqueue
{
public:
    //构造函数
    Blockqueue(size_t capcity = MAX_NUM)
        :_capcity(capcity)
    {
        pthread_mutex_init(&_mutx, nullptr);
        pthread_cond_init(&_pcond, nullptr);
        pthread_cond_init(&_ccond, nullptr);
    }

    //析构函数
    ~Blockqueue()
    {
        pthread_mutex_destroy(&_mutx);
        pthread_cond_destroy(&_pcond);
        pthread_cond_destroy(&_ccond);
    }

    //生产数据
    void push(const T& data)
    {
        //下面的判断就开始使用共享资源，需要加锁
        pthread_mutex_lock(&_mutx);
        //如果当前队列是满的，那就需要将生产者线程加入等待队列挂起
        while(Isfull())
        {
            pthread_cond_wait(&_pcond, &_mutx);
        }
        _q.push(data);
        //唤醒消费者线程消费
        pthread_cond_signal(&_ccond);
        //解锁
        pthread_mutex_unlock(&_mutx);
    }

    //消费数据
    void pop(T* data)
    {
        //下面的判断就开始使用共享资源，需要加锁
        pthread_mutex_lock(&_mutx);
        //如果当前队列是空的，那就需要将消费者线程加入等待队列挂起
        while(_q.empty())
        {
            pthread_cond_wait(&_ccond, &_mutx);
        }
        //将数据输出到data中并删除
        *data = _q.front();
        _q.pop();
        //唤醒生产者线程生产
        pthread_cond_signal(&_pcond);
        //解锁
        pthread_mutex_unlock(&_mutx);
    }

private:
    //检测队列是否装满
    size_t Isfull() const
    {
        return (_q.size() == _capcity);
    }

    std::queue<T> _q;
    pthread_mutex_t _mutx;
    pthread_cond_t _pcond;
    pthread_cond_t _ccond;
    size_t _capcity;
};

//计算器函数
const string ops = "+-*/%";
int calculate(int a, int b, char op)
{
    int result = 0;
    switch(op)
    {
        case '+':
            result = a + b;
            break;
        case '-':
            result = a - b;
            break;
        case '*':
            result = a * b;
            break;
        case '/':
        {
            if(b == 0)
                cerr << "除数不能为0\n";
            else
                result = a / b;
        }
            break;
        case '%':
        {
            if(b == 0)
                cerr << "取模的数字不能为0\n";
            else
                result = a % b;
        }
            break;
        default:
            break;
    }
    return result;
}

//生产者
void* Produce(void* args)
{
    Blockqueue<Task>* bq = (Blockqueue<Task>*)args;
    while(1)
    {
        sleep(1);
        int a = rand()%10;
        int b = rand()%10;
        int opnum = rand()%ops.size();
        Task data(a, b, ops[opnum], calculate);
        string s = "数据生产完成，需要计算：";
        bq->push(data);
        s += data.show_task().c_str();
        cout << s;
    }
    return nullptr;
}

//消费者
void* Consume(void* args)
{
    Blockqueue<Task>* bq = (Blockqueue<Task>*)args;
    while(1)
    {
        //sleep(1);
        Task data;
        string s = "数据消费完成，计算结果为：";
        bq->pop(&data);
        string result = data();
        s += result;
        cout << s;
    }
    return nullptr;
}

#define NUM_PRODUCE 3
#define NUM_CONSUME 3

int main()
{
    srand((unsigned int)time(nullptr));
    Blockqueue<Task>* bq = new Blockqueue<Task>;

    pthread_t ptids[NUM_PRODUCE];
    pthread_t ctids[NUM_CONSUME];

    //创建多个生产者线程
    for(int i = 0; i<NUM_PRODUCE; ++i)
    {
        pthread_create(&ptids[i], nullptr, Produce, (void*)bq);
    }

    //创建多个消费者线程
    for(int i = 0; i<NUM_CONSUME; ++i)
    {
        pthread_create(&ctids[i], nullptr, Consume, (void*)bq);
    }

    //回收所有线程
    for(int i = 0; i<NUM_PRODUCE; ++i)
    {
        pthread_join(ptids[i], nullptr);
    }
    for(int i = 0; i<NUM_CONSUME; ++i)
    {
        pthread_join(ctids[i], nullptr);
    }

    return 0;
}

运行结果：

有一个地方我一直没说，像cout 所以我们在打印信息时尽量使用单句printf或者cout

6.生产消费模型为何高效

该模型中，多个生产者线程向阻塞队列生成数据，多个消费者线程也从阻塞队列中消费数据。

各生产消费者线程之间互斥关系，各线程对于阻塞队列的访问是串行的。同一时间访问阻塞队列的线程只有一个，拿这样又何来高效呢？

注意观察程序的运行逻辑，我们能发现只有临界区的代码是串行的，其他代码所有线程都是并发执行的。这些非临界区的代码通常耗时长，而它们是并发的，所以该模型的效率就变得很高。

结论：生产消费模型的高效不体现在对临界资源的访问上，而是体现在对非临界区代码的并发执行上。

四、双阻塞队列的生产消费模型

我么们可以使用上面的生产者消费者模型，将消费者处理完的计算任务保存成日志，并储存到磁盘上。

所以该模型有两个阻塞队列，一个阻塞队列用于保存计算任务，另一个阻塞队列用于保存保存任务。原来的生产者线程还是生产者，原来的消费者作为中间的线程，既是消费者也是生产者，保存线程是消费者。

1.编写类代码

我们需要构建四个类：计算任务类、保存任务类、阻塞队列类和多队列集合类。

计算任务类就是之前的Task类，我们其他代码不用动，对它改个CalTask的名字就可以。
保存任务类与计算任务类很相似，需要传入一个string表示需要打印的信息，还有一个函数对象表示保存数据的具体执行函数。
阻塞队列类也不用改
多队列集合类是为了线程执行函数的void* args传参设计的，包含了两个阻塞队列指针。

cpp 复制代码

//计算任务类
class CalTask
{
    typedef std::function<int(int,int,char)> func_t;
public:
    //默认构造
    CalTask()
    {}
    //构造函数
    CalTask(int a, int b, char op, func_t func)
        :_a(a)
        ,_b(b)
        ,_op(op)
        ,_func(func)
    {}

    //仿函数
    string operator()()
    {
        int result = _func(_a, _b, _op);
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "%d %c %d = %d\n", _a, _op, _b, result);
        string s(buffer);
        return s;
    }

    //显示任务
    string show_task()
    {
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "%d %c %d = ?\n", _a, _op, _b);
        string s(buffer);
        return s;
    }
private:
    func_t _func;
    int _a;
    int _b;
    char _op;
};

//保存任务类
class SaveTask
{
    typedef function<void(const string&)> func_t;
public:
    //默认构造
    SaveTask()
    {}
    //构造函数
    SaveTask(string message, func_t func)
        :_message(message)
        ,_func(func)
    {}

    //仿函数
    void operator()()
    {
        _func(_message);
    }
private:
    string _message;
    func_t _func;
};

//阻塞队列类
template<class T>
class Blockqueue
{
public:
    //构造函数
    Blockqueue(size_t capcity = MAX_NUM)
        :_capcity(capcity)
    {
        pthread_mutex_init(&_mutx, nullptr);
        pthread_cond_init(&_pcond, nullptr);
        pthread_cond_init(&_ccond, nullptr);
    }

    //析构函数
    ~Blockqueue()
    {
        pthread_mutex_destroy(&_mutx);
        pthread_cond_destroy(&_pcond);
        pthread_cond_destroy(&_ccond);
    }

    //生产数据
    void push(const T& data)
    {
        //下面的判断就开始使用共享资源，需要加锁
        pthread_mutex_lock(&_mutx);
        //如果当前队列是满的，那就需要将生产者线程加入等待队列挂起
        while(Isfull())
        {
            pthread_cond_wait(&_pcond, &_mutx);
        }
        _q.push(data);
        //唤醒消费者线程消费
        pthread_cond_signal(&_ccond);
        //解锁
        pthread_mutex_unlock(&_mutx);
    }

    //消费数据
    void pop(T* data)
    {
        //下面的判断就开始使用共享资源，需要加锁
        pthread_mutex_lock(&_mutx);
        //如果当前队列是空的，那就需要将消费者线程加入等待队列挂起
        while(_q.empty())
        {
            pthread_cond_wait(&_ccond, &_mutx);
        }
        //将数据输出到data中并删除
        *data = _q.front();
        _q.pop();
        //唤醒生产者线程生产
        pthread_cond_signal(&_pcond);
        //解锁
        pthread_mutex_unlock(&_mutx);
    }

private:
    //检测队列是否装满
    size_t Isfull() const
    {
        return (_q.size() == _capcity);
    }

    std::queue<T> _q;
    pthread_mutex_t _mutx;
    pthread_cond_t _pcond;
    pthread_cond_t _ccond;
    size_t _capcity;
};

//多队列集合类
template<class A,class B>
class Blockqueues
{
public:
    Blockqueue<A>* _q1;
    Blockqueue<B>* _q2;
};

2.增加处理保存任务的函数

我们之前对计算任务有一个处理函数calculate，那处理保存任务也同样需要一个函数Savedata。

cpp 复制代码

//保存函数
void Savedata(const string& message)
{
    //需要保存信息的文件
    char buffer[64] = "log.txt";
    //按追加方式打开文件
    FILE* fp = fopen(buffer, "a");
    if(fp == nullptr)
    {
        cerr << "文件打开失败" << endl;
        return;
    }
    fprintf(fp, "%s", message.c_str());
    fclose(fp);
}

3.更改线程函数

生产者线程此时依旧生产，只不过生产的位置是第一个阻塞队列。

消费者线程此时也成为了后一个模型的生产者，那就需要添加向第二个队列生产的代码。

保存者线程此时是消费者，从第二个队列中取任务执行。

cpp 复制代码

//生产者
void* Produce(void* args)
{
    Blockqueues<CalTask, SaveTask>* bqs = (Blockqueues<CalTask, SaveTask>*)args;
    //生产数据
    while(1)
    {
        sleep(1);
        int a = rand()%10;
        int b = rand()%10;
        int opnum = rand()%ops.size();
        CalTask data(a, b, ops[opnum], calculate);
        string s = "数据生产完成，需要计算：";
        bqs->_q1->push(data);
        s += data.show_task().c_str();
        cout << s;
    }
    return nullptr;
}

//消费者
void* Consume(void* args)
{
    Blockqueues<CalTask, SaveTask>* bqs = (Blockqueues<CalTask, SaveTask>*)args;
    while(1)
    {
        //消费数据
        //sleep(1);
        CalTask data;
        string s1 = "数据消费完成，计算结果为：";
        bqs->_q1->pop(&data);
        string result = data();
        s1 += result;
        cout << s1;
        //生成待保存的数据
        string s2 = "数据保存任务推送完毕\n";
        SaveTask task = SaveTask(result, Savedata);
        bqs->_q2->push(task);
         cout << s2;
    }
    return nullptr;
}

void* Save(void* args)
{
    Blockqueues<CalTask, SaveTask>* bqs = (Blockqueues<CalTask, SaveTask>*)args;
    while(1)
    {
        //sleep(1);
        SaveTask data;
        string s = "数据保存完成\n";
        bqs->_q2->pop(&data);
        data();
        cout << s;
    }
    return nullptr;
}

4.更改main函数

最后我们在main函数中创建两个队列，创建三种线程最后加上回收代码就可以了。

所以总代码如下：

produce_consume.h

cpp 复制代码

#include<iostream>
#include<queue>
#include<stdlib.h>
#include<time.h>
#include<unistd.h>
#include<functional>
#include<stdio.h>
#define MAX_NUM 10
using namespace std;
//计算任务类
class CalTask
{
    typedef std::function<int(int,int,char)> func_t;
public:
    //默认构造
    CalTask()
    {}
    //构造函数
    CalTask(int a, int b, char op, func_t func)
        :_a(a)
        ,_b(b)
        ,_op(op)
        ,_func(func)
    {}

    //仿函数
    string operator()()
    {
        int result = _func(_a, _b, _op);
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "%d %c %d = %d\n", _a, _op, _b, result);
        string s(buffer);
        return s;
    }

    //显示任务
    string show_task()
    {
        char buffer[64];
        snprintf(buffer, sizeof(buffer), "%d %c %d = ?\n", _a, _op, _b);
        string s(buffer);
        return s;
    }
private:
    func_t _func;
    int _a;
    int _b;
    char _op;
};

//保存任务类
class SaveTask
{
    typedef function<void(const string&)> func_t;
public:
    //默认构造
    SaveTask()
    {}
    //构造函数
    SaveTask(string message, func_t func)
        :_message(message)
        ,_func(func)
    {}

    //仿函数
    void operator()()
    {
        _func(_message);
    }
private:
    string _message;
    func_t _func;
};

//阻塞队列类
template<class T>
class Blockqueue
{
public:
    //构造函数
    Blockqueue(size_t capcity = MAX_NUM)
        :_capcity(capcity)
    {
        pthread_mutex_init(&_mutx, nullptr);
        pthread_cond_init(&_pcond, nullptr);
        pthread_cond_init(&_ccond, nullptr);
    }

    //析构函数
    ~Blockqueue()
    {
        pthread_mutex_destroy(&_mutx);
        pthread_cond_destroy(&_pcond);
        pthread_cond_destroy(&_ccond);
    }

    //生产数据
    void push(const T& data)
    {
        //下面的判断就开始使用共享资源，需要加锁
        pthread_mutex_lock(&_mutx);
        //如果当前队列是满的，那就需要将生产者线程加入等待队列挂起
        while(Isfull())
        {
            pthread_cond_wait(&_pcond, &_mutx);
        }
        _q.push(data);
        //唤醒消费者线程消费
        pthread_cond_signal(&_ccond);
        //解锁
        pthread_mutex_unlock(&_mutx);
    }

    //消费数据
    void pop(T* data)
    {
        //下面的判断就开始使用共享资源，需要加锁
        pthread_mutex_lock(&_mutx);
        //如果当前队列是空的，那就需要将消费者线程加入等待队列挂起
        while(_q.empty())
        {
            pthread_cond_wait(&_ccond, &_mutx);
        }
        //将数据输出到data中并删除
        *data = _q.front();
        _q.pop();
        //唤醒生产者线程生产
        pthread_cond_signal(&_pcond);
        //解锁
        pthread_mutex_unlock(&_mutx);
    }

private:
    //检测队列是否装满
    size_t Isfull() const
    {
        return (_q.size() == _capcity);
    }

    std::queue<T> _q;
    pthread_mutex_t _mutx;
    pthread_cond_t _pcond;
    pthread_cond_t _ccond;
    size_t _capcity;
};

//多队列集合类
template<class A,class B>
class Blockqueues
{
public:
    Blockqueue<A>* _q1;
    Blockqueue<B>* _q2;
};

produce_consume.cc

cpp 复制代码

#include"produce_consume.h"
using namespace std;

//计算器函数
const string ops = "+-*/%";
int calculate(int a, int b, char op)
{
    int result = 0;
    switch(op)
    {
        case '+':
            result = a + b;
            break;
        case '-':
            result = a - b;
            break;
        case '*':
            result = a * b;
            break;
        case '/':
        {
            if(b == 0)
                cerr << "除数不能为0\n";
            else
                result = a / b;
        }
            break;
        case '%':
        {
            if(b == 0)
                cerr << "取模的数字不能为0\n";
            else
                result = a % b;
        }
            break;
        default:
            break;
    }
    return result;
}

//保存函数
void Savedata(const string& message)
{
    //需要保存信息的文件
    char buffer[64] = "log.txt";
    //按追加方式打开文件
    FILE* fp = fopen(buffer, "a");
    if(fp == nullptr)
    {
        cerr << "文件打开失败" << endl;
        return;
    }
    fprintf(fp, "%s", message.c_str());
    fclose(fp);
}

//生产者
void* Produce(void* args)
{
    Blockqueues<CalTask, SaveTask>* bqs = (Blockqueues<CalTask, SaveTask>*)args;
    //生产数据
    while(1)
    {
        sleep(1);
        int a = rand()%10;
        int b = rand()%10;
        int opnum = rand()%ops.size();
        CalTask data(a, b, ops[opnum], calculate);
        string s = "数据生产完成，需要计算：";
        bqs->_q1->push(data);
        s += data.show_task().c_str();
        cout << s;
    }
    return nullptr;
}

//消费者
void* Consume(void* args)
{
    Blockqueues<CalTask, SaveTask>* bqs = (Blockqueues<CalTask, SaveTask>*)args;
    while(1)
    {
        //消费数据
        //sleep(1);
        CalTask data;
        string s1 = "数据消费完成，计算结果为：";
        bqs->_q1->pop(&data);
        string result = data();
        s1 += result;
        cout << s1;
        //生成待保存的数据
        string s2 = "数据保存任务推送完毕\n";
        SaveTask task = SaveTask(result, Savedata);
        bqs->_q2->push(task);
         cout << s2;
    }
    return nullptr;
}

void* Save(void* args)
{
    Blockqueues<CalTask, SaveTask>* bqs = (Blockqueues<CalTask, SaveTask>*)args;
    while(1)
    {
        //sleep(1);
        SaveTask data;
        string s = "数据保存完成\n";
        bqs->_q2->pop(&data);
        data();
        cout << s;
    }
    return nullptr;
}

#define NUM_PRODUCE 3
#define NUM_CONSUME 3
#define NUM_SAVE 3

int main()
{
    srand((unsigned int)time(nullptr));
    Blockqueues<CalTask, SaveTask>* bqs = new Blockqueues<CalTask, SaveTask>();
    bqs->_q1 = new Blockqueue<CalTask>();
    bqs->_q2 = new Blockqueue<SaveTask>();

    pthread_t ptids[NUM_PRODUCE];
    pthread_t ctids[NUM_CONSUME];
    pthread_t stids[NUM_SAVE];

    //创建多个生产者线程
    for(int i = 0; i<NUM_PRODUCE; ++i)
    {
        pthread_create(&ptids[i], nullptr, Produce, (void*)bqs);
    }

    //创建多个消费者线程
    for(int i = 0; i<NUM_CONSUME; ++i)
    {
        pthread_create(&ctids[i], nullptr, Consume, (void*)bqs);
    }

    //创建多个保存者线程
    for(int i = 0; i<NUM_CONSUME; ++i)
    {
        pthread_create(&stids[i], nullptr, Save, (void*)bqs);
    }

    //回收所有线程
    for(int i = 0; i<NUM_PRODUCE; ++i)
    {
        pthread_join(ptids[i], nullptr);
    }
    for(int i = 0; i<NUM_CONSUME; ++i)
    {
        pthread_join(ctids[i], nullptr);
    }
    for(int i = 0; i<NUM_SAVE; ++i)
    {
        pthread_join(stids[i], nullptr);
    }
    return 0;
}

运行结果：

目录中确实多了一个log.txt，也能看出线程的具体执行轨迹。

基于阻塞队列的生产者消费者模型是线程同步与互斥的充分应用，现实中很多场景都可以应用，是线程中的一大杀器。