今天是一个与互斥锁和条件变量有关的一个模型，生产者消费者模型，为什么要用这个模型呢？其实这个模型我个人感觉的有点就是提高了效率，在多线程的情况下，提高了非常明显。并且解耦了生产者和消费者的关系。下面是一个这个模型的基本思路：
这个模型充分说明了两者的关系，就是一个共用的资源，一个放，一个拿，且有三种关系，两种角色，一个交易场所。取数据的我们可以看成是消费者，放数据的是生产者，交易场所就是这个共用资源，而这个关系我们应该怎样理解呢？就是如果有多个生产者和消费者，那么我们就要出现一个串行关系取数据或是放数据，不然就会乱，所以会很明显的是消费者之间是互斥关系，生产者之间也是互斥，而生产者与消费者是互斥与同步的关系。，所以弄清楚了基本的模型，我们就来看看如何实现。.
注：这个交易场所也就是共用资源可以不是队列，这里只是打个比方，为了更好的理解。
cpp
#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>
#include <cstring>
#include "mtx.hpp"
#include "model.hpp"
#include <time.h>
using namespace std;
//创建线程数量
#define NUMPTHREAD_T 6
//函数指针
typedef void (*func)(int);
//函数声明
void product(int number);
void custcom(int number);
proCust<int> mod;
//判断是生产者还是消费者
struct Pro_or_cust
{
int _number;
string _name;
func _product = product;
func _custcom = custcom;
Pro_or_cust(int number)
: _number(number)
{
}
};
void product(int number)
{
while (true)
{
//同步所有线程
sleep(3);
//随机生成数，项目中一般是做其他任务
int val = rand() % 100000;
cout << "我是生产者" << pthread_self() << " " << number << endl;
mod.push(val, number);
sleep(1);
}
}
void custcom(int number)
{
while (true)
{
cout << "我是消费者" << pthread_self() << " " << number << endl;
int ret = mod.pop(number);
//打印获得数据，一般也可以处理获取的数据
cout << "我消费的数据" << ret << endl;
sleep(1);
}
}
void *enter(void *args)
{
Pro_or_cust *p = (Pro_or_cust *)args;
//判断是生产者还是消费者
if (strcmp(p->_name.c_str(), "custcom") == 0)
p->_custcom(p->_number);
else
p->_product(p->_number);
delete p;
return nullptr;
}
int main()
{
srand((unsigned int)time(nullptr));
pthread_t tid[NUMPTHREAD_T];
for (int i = 0; i < NUMPTHREAD_T; i++)
{
Pro_or_cust *str = new Pro_or_cust(i + 1);
if (i % 2 == 0)
str->_name = "custcom";
else
str->_name = "product";
pthread_create(tid + i, nullptr, enter, str);
// sleep(1);
}
for (int i = 0; i < NUMPTHREAD_T; i++)
{
pthread_join(tid[i], nullptr);
}
cout << "回收资源成功" << endl;
return 0;
}
cpp
#pragma once
#include <iostream>
#include <unistd.h>
#include <queue>
#include <pthread.h>
#include <time.h>
#include "mtx.hpp"
#define NUMSIZE 10
using namespace std;
template <class T>
class proCust
{
public:
proCust(size_t size = NUMSIZE)
: _size(size)
{
pthread_mutex_init(&_mtx, nullptr);
pthread_cond_init(&_full, nullptr);
pthread_cond_init(&_empty, nullptr);
}
void push(const T &x, int number)
{
Rmtx s(_mtx);
cout<<"我抢到锁了"<<number<<" " <<&_mtx<<endl;
sleep(1);
while (_size == _q.size())
{
pthread_cond_signal(&_empty);
pthread_cond_wait(&_full, &_mtx);
}
_q.push(x);
cout << "我是生产者：" << number << "号"
<< " "
<< "我的tid: " << pthread_self() << endl;
}
T pop(int number)
{
Rmtx s(_mtx);
cout<<"我抢到锁了"<<number<<" " <<&_mtx<<endl;
sleep(1);
while (_q.size() == 0)
{
pthread_cond_signal(&_full);
pthread_cond_wait(&_empty, &_mtx);
}
T x = _q.front();
_q.pop();
cout << "我是消费者：" << number << "号"
<< " "
<< "我的tid: " << pthread_self() << endl;
return x;
}
~proCust()
{
pthread_mutex_destroy(&_mtx);
pthread_cond_destroy(&_full);
pthread_cond_destroy(&_empty);
}
private:
size_t _size;
queue<T> _q;
pthread_cond_t _full;
pthread_cond_t _empty;
pthread_mutex_t _mtx;
};
cpp
#pragma once
#include <iostream>
#include <pthread.h>
#include <utility>
//RAII风格的加锁方式
struct Rmtx
{
public:
Rmtx(pthread_mutex_t &mtx)
: _mtx(mtx)
{
pthread_mutex_lock(&_mtx);
std::cout << "已上锁" << std::endl;
}
~Rmtx()
{
pthread_mutex_unlock(&_mtx);
std::cout << "已解锁" << std::endl;
}
private:
pthread_mutex_t &_mtx;
};首先是两个头文件，一个test.cc文件。
这个模型本身很简单，但是实现起来，个人认为还是要有不少注意的点，而且不好找出错误。
首先给大家说说实现这个模型我个人认为要注意的点。
1.如果有小伙伴想给新线程传编号，就是第几个创建的线程，这里一定要注意。那就是因为pthread_create这个函数本身不会有延迟，但是奈何这个函数中，是创建一个新线程，也就是说这个函数内部就会分开，一个是新线程，一个是主线程，而主线程的速度要比新线程快，所以有可能就是主线程运行到第二次循环了，新线程可能才创建好，所以这里有时候会达不到自己的预期，切代码正确，就是检查不出错误原因。
2.其次就是这个RAII的风格方式加锁，不知道大家写的时候有没有遇见过，就是把锁的初始化写到了构造函数(上面的代码是写到Rmtx中构造函数)，其实这样写是错的，这样的话类似于加不上锁，我也测试了很长时间才发现，因为这样的话每个线程都会创建一个这个对象，所以会把这个锁初始化好多次，造成类似于没有加锁的那种情况，就是多线程共同访问临界资源，这个一定要注意。
我上网查了下类似于同步多次初始化的结果，但是没查到，有的也没看懂，我个人认为可能是破坏了锁，所以导致错误。
多线程部分出现错误还是比较难调试的，所以一定要小心。
希望大家支持！！！