基于阻塞队列(条件变量 + 锁)的生产者消费者模型

基于阻塞队列(条件变量 + 锁)的生产者消费者模型

BlockQueue.hpp (阻塞队列)

c++ 复制代码
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <vector>
#include <queue>
#include "sem.hpp"
#include "Mutex.hpp"
#include "Cond.hpp"
using namespace std;

#define BLOCKQUEUESIZE 5
template <class T>
class BlockQueue
{
public:
    BlockQueue(int num = BLOCKQUEUESIZE)
    :num_(num)
    {}
    void push(const T& in)
    {
        T t = in;
        lock_Guard mtx(mtx_);
        if(isFull())
            cv_space_.Wait(mtx);
        block_queue_.push(t);
        cv_data_.notify_one();
    }
    T pop()
    {
        lock_Guard mtx(mtx_);
        if(isEmpyt())
            cv_data_.Wait(mtx);
        T t = block_queue_.front();
        block_queue_.pop();
        cv_space_.notify_one();
        return t;
    }
    bool isEmpyt() {return block_queue_.empty();}
    bool isFull() {return block_queue_.size() == num_;}
private:
    queue<T> block_queue_;
    int num_;
    Mutex mtx_;
    Condition_variable cv_data_;
    Condition_variable cv_space_;
};

Cond.hpp (封装条件变量)

c++ 复制代码
#include <iostream>
#include <cstdlib>
#include "Mutex.hpp"
class Condition_variable
{
public:
    Condition_variable()
    {
        pthread_cond_init(&cond_,nullptr);
    }
    void Wait(lock_Guard& lg)
    {
        pthread_cond_wait(&cond_,lg.getMutex());
    }
    void notify_one()
    {
        pthread_cond_signal(&cond_);
    }
    void notify_all()
    {
        pthread_cond_broadcast(&cond_);
    }
    ~Condition_variable()
    {
        pthread_cond_destroy(&cond_);
    }
private:
    pthread_cond_t cond_;
};

Mutex.hpp (封装锁)

c++ 复制代码
#include <iostream>
#include <cstdlib>
#ifndef MUTEX_HPP
#define MUTEX_HPP
class Mutex
{
public:
    Mutex()
    {
        pthread_mutex_init(&mutex_, nullptr);
    }
    void lock()
    {
        pthread_mutex_lock(&mutex_);
    }
    void unlock()
    {
        pthread_mutex_unlock(&mutex_);
    }
    pthread_mutex_t* getMutex()
    {
        return &mutex_;
    }
    ~Mutex()
    {
        pthread_mutex_destroy(&mutex_);
    }
    Mutex(const Mutex& mtx) = delete;
    Mutex& operator=(const Mutex& mtx) = delete;
private:
    pthread_mutex_t mutex_;
};

class lock_Guard
{
public:
    lock_Guard(Mutex& mutex)
    :mutex_(mutex)
    {
        mutex_.lock();
    }
    ~lock_Guard()
    {
        mutex_.unlock();
    }
    pthread_mutex_t* getMutex()
    {
        return mutex_.getMutex();
    }
    lock_Guard(const lock_Guard& lg) = delete;
    lock_Guard& operator=(const lock_Guard& lg) = delete;
private:
    Mutex& mutex_;
};
#endif

main.cc

c++ 复制代码
#include "BlockQueue.hpp"
#include <pthread.h>
#define CUSTOMERSIZE 2
#define PRODUCTORSIZE 1
class Task
{
public:
    Task(int x,int y)
    :x_(x),y_(y)
    {}
    int operator()()
    {
        return x_ + y_;
    }
    int x_;
    int y_;
};
struct MyThread
{
    BlockQueue<Task>* rg;
    string name;
};
void* customer(void* args)
{
    MyThread* mt = (MyThread*)args;
    BlockQueue<Task>* rg = mt->rg;
    string name = mt->name;
    sleep(5);
    while(true)
    {
        Task task = rg->pop();
        int ans = task();
        cout << name << ": " << task.x_ << " + " << task.y_ << " = " << ans << endl;
    }
    return nullptr;
}
void* productor(void* args)
{
    MyThread* mt = (MyThread*)args;
    BlockQueue<Task>* rg = mt->rg;
    string name = mt->name;
    while(true)
    {
        int x = rand()%100+1;
        usleep(100);
        int y = rand()%100+1;
        rg->push(Task(x,y));
        cout << name << ": " << x << " + " << y << " = ?"<<endl;
        sleep(1);
    }
    return nullptr;
}
int main()
{
    srand(time(NULL));
    BlockQueue<Task> rg(3);
    MyThread c_mt[CUSTOMERSIZE];
    MyThread p_mt[PRODUCTORSIZE];
    pthread_t c[CUSTOMERSIZE];
    pthread_t p[PRODUCTORSIZE];
    for(int i=0;i<CUSTOMERSIZE;++i)
    {
        c_mt[i].rg = &rg;
        string name = "customer ";
        name += to_string(i+1);
        c_mt[i].name=name;
        pthread_create(c+i,nullptr,customer,(void*)(c_mt+i));
    } 
    for(int i=0;i<PRODUCTORSIZE;++i)
    {
        p_mt[i].rg = &rg;
        string name = "productor ";
        name += to_string(i+1);
        p_mt[i].name=name;
        pthread_create(p+i,nullptr,productor,(void*)(p_mt+i));
    } 

    for(int i=0;i<CUSTOMERSIZE;++i)
    {
        pthread_join(c[i],nullptr);
    } 
    for(int i=0;i<PRODUCTORSIZE;++i)
    {
        pthread_join(p[i],nullptr);
    } 
    return 0;
}

makefile

makefile 复制代码
blockQueue:main.cc
	g++ -o $@ $^ -std=c++11 -l pthread
.PHONY:clean
clean:
	rm -f blockQueue
相关推荐
mit6.8241 小时前
并查集|栈
c++
中国胖子风清扬1 小时前
Rust 序列化技术全解析:从基础到实战
开发语言·c++·spring boot·vscode·后端·中间件·rust
learning_tom2 小时前
HTML图片标签及路径详解
linux·服务器·php
岁忧2 小时前
(LeetCode 面试经典 150 题) 200. 岛屿数量(深度优先搜索dfs || 广度优先搜索bfs)
java·c++·leetcode·面试·go·深度优先
dbdr09012 小时前
Linux 入门到精通,真的不用背命令!零基础小白靠「场景化学习法」,3 个月拿下运维 offer,第二十六天
linux·运维·服务器·网络·python·学习
一枝小雨2 小时前
【OJ】C++ vector类OJ题
数据结构·c++·算法·leetcode·oj题
一枝小雨2 小时前
【C++】Vector完全指南:动态数组高效使用
开发语言·c++·笔记·vector·学习笔记·std库
大白的编程日记.3 小时前
【Linux学习笔记】信号的深入理解之软件条件产生信号
linux·笔记·学习
buyutang_3 小时前
C/C++ Linux系统编程:线程控制详解,从线程创建到线程终止
linux·c语言·c++·学习
云的牧人3 小时前
Ubuntu 22 redis集群搭建
linux·运维·ubuntu