目录
举例 -- 超市
说到消费场所,我们首先能想到的就是超市
- 超市是一个综合性比较强的交易场所,我们可以在里面买到各种商品
那商品从哪来呢?难道是超市自己生产的吗?
- 自然不是
- 是由各个供货商提供
- 也就是说,供货商提供商品给超市,消费者在超市拿到商品
那为什么消费者一定要在超市消费呢?
- 如果不在超市,那么对应的就要在供货商处消费 -- 消费者需要自行去各个厂家购买相应产品
- 首先就是消费者自己的效率问题,如果要买多种商品,就要去多个厂家
- 其次是厂家的效率问题,来一个消费者才生产一件货物(不然可能会产生货物积压的问题)
- 而且,厂家的工作时间不一定是消费者的闲暇时间
所以,超市存在的意义就是解决上述问题
- 它可以一次性向厂家要很多货物,放在超市里,等待顾客自行挑选
- 并且,可以摆放多个货物,消费者只需要在超市这一个场所中,就可以拿到不同货物
- 它可以协调生产者和消费者的忙闲时间
超市就可以看作是生产消费者模型的一种实际应用
介绍
概念
- 生产者-消费者模型（Producer-Consumer Model）是一种并发计算模型，用于解决多线程或多进程之间的协作和数据共享问题
- 其中生产者负责生成数据或任务，而消费者则负责处理这些数据或任务
- 模型的目标是协调和同步生产者和消费者的活动，以确保数据被正确处理且不发生冲突
我们可以将生产消费者模型概括为下面三个原则:
2种角色
- 自然是生产者和消费者
- 在计算机中可以看作是两个线程 / 多个线程(因为可能会存在多个生产者/消费者)
1个交易场所
- 也就是超市充当的角色
- 在计算机中是一块共享的缓冲区 / 一种数据结构,是两个角色都可以访问到的一块空间
- 一个生成数据或任务，将其放入共享的缓冲区中 ; 一个从共享缓冲区中取出数据或任务，并进行相应的处理
3种关系
生产者之间
首先,因为可能存在多个生产者,自然需要维护生产者和生产者的关系
- 也就是互斥关系/竞争关系
- 同一个位置,只能有一个生产者的货物放上去
- 是不是和之前说的[只能有一个线程访问临界资源]很相似?
- 所以对应的,我们需要对生产的过程加锁保护
消费者之间
和生产者之间的关系类似
- 如果有多个消费者,他们之间也是互斥/竞争关系
- 虽然我们平时没有见到在超市里有争夺的现象,但那是因为超市里的资源多
- 如果全超市只剩下一包泡面,就会抢起来了(因为只有一个人可以拿到那包泡面)
- 在现实生活中,这样的前提是自然存在的 ; 但计算机中,需要用代码去实现
- 所以,为了保证一个货物只有一个消费者去消费,就要进行加锁保护噜
生产者和消费者
关系
这是最重要的关系了,毕竟可能存在只有一个消费者,一个生产者的情况,那上面两种关系就不存在了
- 生产者和消费者之间会存在互斥关系
- 毕竟,你不能在生产者正在生产时,去试图拿取东西吧 (你无法确定此时是否生产完成,自然拿取行为也就是不确定的)
- 反过来也是一样的
- 所以我们要保证生产和消费的过程是原子的,也就是进行加锁保护(当然,这个已经在上面提到过了)
互相等待
- 除此之外,最重要的是,生产者和消费者是有一定顺序的
- 只有当生产者生产出东西了,消费者才能去消费
- 并且,缓冲区的情况也需要被考虑
- 当缓冲区为空时，消费者直到生产者放入数据后,才可以消费
- 当缓冲区满时，生产者直到消费者取出数据后,才可以生产
- 而双方互相等待对方的行为,是不是很熟悉?很像管道通信!
- 如果将生产者和消费者各自看作一个线程,东西也就是数据
- 那么一方生产,一方消费,不就是双方在进行单向通信吗?
那消费者和生产者如何得知缓冲区的情况呢?
- 必须得访问吧
- 那就出现了之前介绍过的,抢票前需要先确定票是否就绪的问题
- 因为不知道何时就绪,线程就需要不断访问临界资源
- 但这是一种不必要的行为,因为我们可以引入条件变量来解决
- 当票就绪时,让修改资源的线程通知到等待的线程即可
- 这里也是一样
- 消费者需要货物,只有生产者最清楚是否有货物(因为货物就是他生产出来的)
- 生产者需要确定它此时是否可以生产,也就是需要空位,只有消费者最清楚是否有空位(因为空位就是它消费导致的)
- 所以,让他俩互相通知对方即可,而这样也就自然形成了顺序
阻塞队列
介绍
- 在多线程编程中,阻塞队列(Blocking Queue)是一种常用于实现生产者和消费者模型的数据结构
- 其与普通的队列区别在于"阻塞"功能
- 当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素 ；当队列满时，往队列里存放元素的操作也会被阻塞，直到有元素被从队列中取出
- (以上的操作都是基于不同的线程来说的，线程在对阻塞队列进程操作时会被阻塞)
模拟实现 -- 基础版
思路
我们将阻塞队列封装成一个类
- 对于队列来说,核心操作就是push和pop
- 队列我们使用stl中的queue
- 除此之外,需要一把锁,用来确保生产和消费不会互相影响
- 并且,为了提高效率,我们使用两个条件变量(分别对应两个等待队列),生产者一个,消费者一个
- (如果只有一个的话,唤醒时就无法确定唤醒的是消费者还是生产者了)
实际的工作由类内函数实现,但分配任务/资源时,是分配给线程的
- 所以,创建线程时,可以直接传递类过去
- 使用时,进行调用即可
从前面的介绍也可以知道,在进行生产/消费前,需要确保资源满足某种条件
- 如果满足,就进行相应的处理
- 如果不满足,需要等待某个条件变量
- 而这个条件变量,是由对方改变的
- (比如,生产者需要确保此时有空间让它生产,而这个空间是由消费者消费产生的,所以当消费者消费完后,就可以通知生产者来生产了 ; 反过来也是一样的)
代码
#include <iostream> #include <string> #include <pthread.h> #include <unistd.h> #include <sys/types.h> #include <vector> #include <cassert> #include <queue> using namespace std; const int def_capacity = 10; template <class T> class BlockQueue { public: BlockQueue(int capacity = def_capacity) : capacity_(capacity) { pthread_mutex_init(&mutex_, nullptr); pthread_cond_init(&is_there_, nullptr); pthread_cond_init(&is_full_, nullptr); } ~BlockQueue() { pthread_mutex_destroy(&mutex_); pthread_cond_destroy(&is_there_); pthread_cond_destroy(&is_full_); } void push(const T &in) { // push需要保证和pop互斥,且队列不能满 pthread_mutex_lock(&mutex_); if (isfull()) { pthread_cond_wait(&is_full_, &mutex_); } bq_.push(in); // 生产完,就可以通知消费者 pthread_cond_signal(&is_there_); pthread_mutex_unlock(&mutex_); } void pop(T &out) // 和push同理 { pthread_mutex_lock(&mutex_); if (isempty()) { pthread_cond_wait(&is_there_, &mutex_); } out = bq_.front(); bq_.pop(); // 消费完,就可以通知生产者 pthread_cond_signal(&is_full_); pthread_mutex_unlock(&mutex_); } bool isfull() { return capacity_ == bq_.size(); } bool isempty() { return 0 == bq_.size(); } private: queue<T> bq_; pthread_mutex_t mutex_; pthread_cond_t is_there_; pthread_cond_t is_full_; int capacity_; };#include "BlockQueue.hpp" void *c_func(void *args) { //sleep(1); BlockQueue<int> *bq = (BlockQueue<int> *)args; int data; while (true) { bq->pop(data); cout << "我消费了 : " << data << endl; } return nullptr; } void *p_func(void *args) { BlockQueue<int> *bq = (BlockQueue<int> *)args; int data = 1; while (true) { cout << "我生产了 : " << data << endl; bq->push(data++); } return nullptr; } void test1() { pthread_t tid1, tid2; BlockQueue<int> *bq = new BlockQueue<int>; pthread_create(&tid1, nullptr, c_func, bq); pthread_create(&tid2, nullptr, p_func, bq); pthread_join(tid1, nullptr); pthread_join(tid2, nullptr); }
pthread_cond_wait的第二个参数为什么是把锁
- 从上面的代码可以看出来,我们的wait函数需要一个条件变量+一把锁,且这把锁就是函数此时所处的锁
为什么呢?
- 条件变量是为了指定线程要去哪个等待队列中等待
那锁呢?
- 还记得我们为什么要等待吗,是因为此时条件不满足,但不能让线程一直去访问
- 所以整出了条件变量,让线程去等待通知
- 那必然会有其他线程去修改临界资源(不修改怎么满足条件呢)
- 如果此时等待的线程还持有锁的话,其他线程就进不去临界区了,也就不存在修改,也就不会有通知
- 所以,必须要让陷入等待的线程先释放锁,再等待
- 等其他线程使临界资源就绪后,就可以通知正在等待的线程,让他们继续执行
- 并且,他们会重新持有锁,因为继续执行的位置必然在锁范围内,要是没有锁,就不合理了
- 所以,wait函数需要知道,他此时在哪个锁的范围内,有了锁,才可以进行解锁和加锁
伪唤醒问题
介绍
- 我们原先的代码中,只要wait调用结束(也就是被消费者唤醒),就直接进行生产了
- 但是,只要是函数,就有调用失败的可能
- 如果此时wait调用失败,意味着在队列满了的情况下,消费者可能并没有进行消费
- 而此时直接进行push,就可能导致越界访问
- 所以,我们可以考虑将if改为while循环,保证当队列不满的情况下,才能执行push
- pop函数也是一样
代码
void push(const T &in) { // push需要保证和pop互斥,且队列不能满 pthread_mutex_lock(&mutex_); while (isfull()) { pthread_cond_wait(&is_full_, &mutex_); } bq_.push(in); // 生产完,就可以通知消费者 pthread_cond_signal(&is_there_); pthread_mutex_unlock(&mutex_); } void pop(T &out) // 和push同理 { pthread_mutex_lock(&mutex_); while (isempty()) { pthread_cond_wait(&is_there_, &mutex_); } out = bq_.front(); bq_.pop(); // 消费完,就可以通知生产者 pthread_cond_signal(&is_full_); pthread_mutex_unlock(&mutex_); }
示例
如果不对生产和消费的过程进行限制,双方就会一直快速执行:
如果让生产先进行一会,随后再放出消费者,且消费者是慢于生产的:
void *c_func(void *args) { sleep(1); BlockQueue<int> *bq = (BlockQueue<int> *)args; int data; while (true) { bq->pop(data); cout << "我消费了 : " << data << endl; sleep(2); } return nullptr; } void *p_func(void *args) { BlockQueue<int> *bq = (BlockQueue<int> *)args; int data = 1; while (true) { cout << "我生产了 : " << data << endl; bq->push(data++); } return nullptr; }
生产者会先生产一堆数据,随后消费者慢慢按照生产的顺序一个一个消费
如果生产慢一点:
消费者会等待生产者,生产一个,才能消费一个
优点
引入
- 其实,从上面的代码中,看不出来这样的设计有什么很大的作用
- 只是两个线程将某个数据运输过去了而已,并且还因为锁,必须等待对方完成,自己才能开始工作
- 这有什么意义呢?
介绍
- 实际上,是我们没有模拟出真实的情况
- 生产和消费数据都需要耗费时间,并不是简单的拷贝就完成了
- 数据的获取可能从网络中/第三方那里来,拿到数据后的处理也可能耗费一定时间
- 设计让生产者和消费者作为单独的线程来处理数据,就是为了让双方在对方进行前提事件/后续处理的时候,还可以继续生产/消费(也就是执行临界区代码),而不是等待一系列操作完成后,再进行生产/消费
- 也就是所谓的,协调了忙闲时间
- 这样可以提高程序的并发度,也就提高了效率
模拟实现 -- 进阶版
增加生产/消费规则
除了像上面那样,生产一个就可以消费一个,也可以制定某种规则
- 等数据>=2/3时,才会消费
- 等数据<=1/2时,才会生产
- 这些规则都可以随意制定,主要看场景如何
生产任务(随机)
思路
- 既然要生产任务,我们首先要构建出一个任务
- 我们可以定义一个类,将任务需要的数据和方法都作为类成员,这样一个类就可以囊括多种任务
- 然后将这个类作为队列成员,生产时,只需要导入数据和方法即可
代码
task.hpp
#pragma once #include <iostream> #include <string> #include <functional> using namespace std; //typedef function<int(int, int)> function_t; using function_t = function<int(int, int)>; class Task { public: Task() {} // 方便只是为了接收传参而定义一个对象 Task(int x, int y, function_t func) : x_(x), y_(y), func_(func) { } int get_x() { return x_; } int get_y() { return y_; } private: int x_; int y_; function_t func_; };主文件
#include "BlockQueue.hpp" int func_add(int x, int y) { return x + y; } void *c_func(void *args) { BlockQueue<Task> *bq = (BlockQueue<Task> *)args; while (true) { Task t; bq->pop(t); cout << "我消费了 : " << t.get_x() << " + " << t.get_y() << " = " << (t.get_x() + t.get_y()) << endl; } return nullptr; } void *p_func(void *args) { BlockQueue<Task> *bq = (BlockQueue<Task> *)args; while (true) { int x = rand() % 10 + 1; int y = rand() % 10 + 1; Task t(x, y, func_add); cout << "我生产了 : " << x << " + " << y << " = ? " << endl; bq->push(t); sleep(2); } return nullptr; } void test1() { srand(getpid() ^ (unsigned int)time(nullptr) ^ 0x1233412); pthread_t tid1, tid2; BlockQueue<Task> *bq = new BlockQueue<Task>; pthread_create(&tid1, nullptr, c_func, bq); pthread_create(&tid2, nullptr, p_func, bq); pthread_join(tid1, nullptr); pthread_join(tid2, nullptr); }
示例
这样我们就可以自动将生成的随机数进行加法运算噜
生产任务(从键盘读入)
除了随机生成,也可以自行导入数据
代码
void *p_func(void *args) { BlockQueue<Task> *bq = (BlockQueue<Task> *)args; while (true) { int x, y; cout << "please enter x : "; cin >> x; cout << "please enter y : "; cin >> y; Task t(x, y, func_add); cout << "我生产了 : " << x << " + " << y << " = ? " << endl; bq->push(t); sleep(2); } return nullptr; }
示例
锁的封装(RAII风格)
思路
- RAII风格主要是 -- 资源的获取和释放应该与对象的生命周期绑定
- 这种编程范式确保在对象生命周期结束时，资源的释放是自动进行的，从而降低了资源泄漏的风险
- 所以,我们将锁的加锁/解锁和类结合在一起,这样就不用手动操作了
代码
// RAII风格 -- 借助类的特点 class Lock_Guard { public: Lock_Guard(pthread_mutex_t *pmux) : pmux_(pmux) { pthread_mutex_lock(pmux_); // 类被定义时,就加锁 } ~Lock_Guard() { pthread_mutex_unlock(pmux_); // 出当前作用域后就销毁 } // 锁的初始化和销毁都在阻塞队列中完成了 public: pthread_mutex_t *pmux_; }; void push(const T &in) { // push需要保证和pop互斥,且队列不能满 Lock_Guard lock(&mutex_); // 被定义出来后,就会自动加锁 while (isfull()) { pthread_cond_wait(&is_full_, &mutex_); } bq_.push(in); // 生产完,就可以通知消费者 pthread_cond_signal(&is_there_); // 出这个函数后,会自动解锁 } void pop(T &out) // 和push同理 { Lock_Guard lock(&mutex_); // 被定义出来后,就会自动加锁 while (isempty()) { pthread_cond_wait(&is_there_, &mutex_); } out = bq_.front(); bq_.pop(); // 消费完,就可以通知生产者 pthread_cond_signal(&is_full_); // 出这个函数后,会自动解锁 }
模拟实现 -- 多生产多消费
代码
void test2() { srand(getpid() ^ (unsigned int)time(nullptr) ^ 0x1233412); pthread_t tid1[2], tid2[2]; BlockQueue<Task> *bq = new BlockQueue<Task>; pthread_create(tid1, nullptr, c_func, bq); pthread_create(tid1 + 1, nullptr, c_func, bq); pthread_create(tid2, nullptr, p_func, bq); pthread_create(tid2 + 1, nullptr, p_func, bq); pthread_join(tid1[0], nullptr); pthread_join(tid1[1], nullptr); pthread_join(tid2[0], nullptr); pthread_join(tid2[1], nullptr); }可以看到,生产和消费各自有两个线程去执行:
优点
- 也许你会觉得没有必要,因为加入更多的线程,会让锁资源的竞争更加激烈,调度成本也增加了
- 但其实只是让临界区的执行成本增加了点,在之外的区域效率还是变高了的
- 还记得前面我们说过的,获取数据和拿到数据后的处理都是会花费一定时间的,但这块区域是没有锁覆盖的
- 也就是说,这块区域允许多个执行流进入
- 那么,采用多生产/多消费,可以使多个执行流并发的完成这些工作,加速生产消费进程 -- 因为生产和消费是有一定顺序的,如果线程迟迟卡在其他工作上,会减少生产/消费的次数,进而拖累消费/生产
- 所以,多线程去执行,对于前序/后续工作耗费时间较长的任务来说,可以提高效率
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
