引言
在上一篇文章中，我们深入探讨了Linux操作系统中的POSIX信号量，这是一个强大的同步机制，用于协调进程或线程对共享资源的访问。通过对信号量的深入理解和应用，我们学习了如何有效地解决并发编程中的竞争条件，确保程序的稳定性和效率。随着并发编程技术的不断深入，理解和掌握更多同步模型对于开发高性能、可靠的软件系统变得尤为重要。因此，本篇文章将继续我们的并发编程之旅，引入一个经典且实用的同步模型——基于环形队列的生产者消费者模型。
在本文中，我们将详细探讨基于环形队列的生产者消费者模型的设计和实现。我们将介绍环形队列的数据结构，分析生产者和消费者之间的同步机制，探索如何利用前文提到的POSIX信号量以及其他同步工具（如互斥锁）来实现生产者和消费者之间高效、安全的数据交换。通过具体的代码示例和案例分析，读者将能够深入理解生产者消费者模型的工作原理，掌握如何在实际项目中设计和实现基于环形队列的高效同步模型。
探索基于环形队列的生产者消费者模型，不仅能够加深我们对并发编程同步机制的理解，还能够提升我们解决实际问题的能力。让我们一起继续并发编程的探索之旅，解锁更多的编程技巧和知识。
一、生产者消费者模型
生产者消费者模型是并发编程中一个经典且重要的问题模型，它描述了两类主体——生产者（Producer）和消费者（Consumer）在并发环境下对共享资源（通常是缓冲区或队列）的访问模式。生产者负责生成数据并将其放入缓冲区，而消费者则从缓冲区取出数据进行处理。该模型的核心在于解决生产者和消费者之间的同步与通信问题，保证数据在生产和消费时的一致性和可用性，同时避免资源的冲突和浪费。对于希望深入了解生产者消费者模型的读者，我们在之前的内容中有所介绍——链接：⭕生产者消费者模型
通过上述简介，希望读者能够对生产者消费者模型有一个初步的认识和理解。在并发编程的实践中，该模型不仅是一个常见的问题场景，也提供了一种思考并发问题的方法论，对于提高编程技能和系统设计能力都有重要意义。
二、环形队列简介
环形队列是一种固定大小的、使用数组实现的队列数据结构，特别在于其首尾相连的循环特性。这种结构允许当数组达到其容量上限时，新加入的元素可以放置在数组的开始位置（如果那里有空位）。环形队列的这一设计使得它在空间利用和操作效率上具有显著优势，尤其适用于有固定缓冲区需求的场景。
🚩主要特点包括：
- 固定大小：一旦创建，队列的大小就固定不变。
- 高效操作：入队和出队操作都非常高效，因为它们仅涉及指针的简单移动。
- 两个指针：使用头指针和尾指针来分别追踪队列的第一个和最后一个元素。
环形队列广泛应用于操作系统、网络通信、生产者消费者模型等多个领域，特别是在需要高效管理固定缓冲区资源的场合。实现环形队列时，关键在于正确管理头尾指针的位置，并准确判断队列的空或满状态。
三、基于环形队列的生产者消费者模型（C++ 代码模拟实现）
⭕Makefile文件
ring_queue:testMain.cc g++ -o $@ $^ -std=c++11 -lpthread .PHONY:clean clean: rm -f ring_queue
这段代码是一个Makefile脚本，用于编译和清理一个名为ring_queue的项目。
⭕ . h 头文件
✅sem.hpp
// 防止头文件重复包含的预处理指令。 #ifndef _SEM_HPP_ #define _SEM_HPP_ // 引入输入输出流库，虽然在此代码中未直接使用，可能为后续扩展预留。 #include <iostream> // 引入POSIX信号量的头文件。 #include <semaphore.h> // 定义一个类 Sem。 class Sem { public: // 构造函数，接收一个整数value作为信号量的初始值。 Sem(int value) { // 初始化信号量，其中&sem_是信号量对象的地址， // 0表示信号量是当前进程的局部信号量， // value是信号量的初始值。 sem_init(&sem_, 0, value); } // p操作，也称为wait操作，用于减少信号量的值。 // 如果信号量的值为0，则调用此方法的线程将阻塞，直到信号量的值大于0。 void p() { sem_wait(&sem_); } // v操作，也称为signal操作，用于增加信号量的值。 // 如果有其他线程因为等待此信号量而阻塞，则它们中的一个将被唤醒。 void v() { sem_post(&sem_); } // 析构函数，用于销毁信号量。 ~Sem() { sem_destroy(&sem_); } private: // 私有成员变量，存储信号量对象的实例。 sem_t sem_; }; // 预处理指令的结束标志。 #endif
这个Sem类提供了简单的接口来进行信号量的基本操作：初始化（构造函数）、等待（p方法）、信号（v方法）和销毁（析构函数）。通过这个类，可以更方便地在C++项目中使用POSIX信号量进行同步操作。
✅ringQueue.hpp
// 防止头文件重复包含的预处理指令。 #ifndef _Ring_QUEUE_HPP_ #define _Ring_QUEUE_HPP_ // 引入所需的头文件。 #include <iostream> #include <vector> #include <pthread.h> #include "sem.hpp" // 定义一个全局常量作为队列的默认大小。 const int g_default_num = 5; // 定义一个模板类RingQueue，用于实现环形队列。 template<class T> class RingQueue { public: // 构造函数，参数default_num指定队列的大小，默认为g_default_num。 RingQueue(int default_num = g_default_num) : ring_queue_(default_num), num_(default_num), c_step(0), p_step(0), space_sem_(default_num), // 初始化空间信号量，表示可用空间数量。 data_sem_(0) // 初始化数据信号量，表示队列中的数据项数量。 { pthread_mutex_init(&clock, nullptr); // 初始化消费者互斥锁。 pthread_mutex_init(&plock, nullptr); // 初始化生产者互斥锁。 } // 析构函数，销毁互斥锁。 ~RingQueue() { pthread_mutex_destroy(&clock); pthread_mutex_destroy(&plock); } // push方法，生产者调用，向队列中添加元素。 void push(const T &in) { space_sem_.p(); // 等待有空间可写。 pthread_mutex_lock(&plock); // 获取生产者互斥锁。 ring_queue_[p_step++] = in; // 将元素添加到队列中。 p_step %= num_; // 环形逻辑，如果到达末尾则回到开始。 pthread_mutex_unlock(&plock); // 释放生产者互斥锁。 data_sem_.v(); // 增加数据信号量，表示有新数据可读。 } // pop方法，消费者调用，从队列中取出元素。 void pop(T *out) { data_sem_.p(); // 等待有数据可读。 pthread_mutex_lock(&clock); // 获取消费者互斥锁。 *out = ring_queue_[c_step++]; // 从队列中取出元素。 c_step %= num_; // 环形逻辑，如果到达末尾则回到开始。 pthread_mutex_unlock(&clock); // 释放消费者互斥锁。 space_sem_.v(); // 增加空间信号量，表示有空间可写。 } private: std::vector<T> ring_queue_; // 使用vector存储队列元素。 int num_; // 队列的大小。 int c_step; // 消费者在队列中的当前位置。 int p_step; // 生产者在队列中的当前位置。 Sem space_sem_; // 控制队列空间的信号量。 Sem data_sem_; // 控制队列中数据的信号量。 pthread_mutex_t clock; // 消费者互斥锁。 pthread_mutex_t plock; // 生产者互斥锁。 }; #endif // 预处理指令的结束标志。
这个环形队列的实现利用信号量space_sem_和data_sem_来控制队列的空间和数据，确保生产者不会在队列满时添加元素，消费者不会在队列空时尝试取出元素。同时，通过两个互斥锁clock和plock分别保护消费者和生产者的操作，防止并发环境下的数据竞争问题。这样的设计使得RingQueue既能高效地管理数据，又能保证线程安全。
⭕ . cpp 文件
✅testMain.cpp
// 包含RingQueue类的头文件。 #include "ringQueue.hpp" #include <cstdlib> // 包含标准库，用于rand()等函数。 #include <ctime> // 用于time()函数。 #include <sys/types.h> // 包含类型定义，例如pid_t。 #include <unistd.h> // 包含各种常量和类型，并声明了各种函数，例如sleep()和getpid()。 // 消费者线程的工作函数。 void *consumer(void *args) { RingQueue<int> *rq = (RingQueue<int> *)args; // 将传入的参数转换为RingQueue指针。 while(true) { sleep(1); // 休眠1秒，模拟处理时间。 int x; rq->pop(&x); // 从环形队列中取出一个元素。 // 打印消费信息，包括消费的值和当前线程ID。 std::cout << "消费: " << x << " [" << pthread_self() << "]" << std::endl; } } // 生产者线程的工作函数。 void *productor(void *args) { RingQueue<int> *rq = (RingQueue<int> *)args; // 将传入的参数转换为RingQueue指针。 while(true) { int x = rand() % 100 + 1; // 生成一个1到100之间的随机数。 // 打印生产信息，包括生产的值和当前线程ID。 std::cout << "生产: " << x << " [" << pthread_self() << "]" << std::endl; rq->push(x); // 将生成的随机数放入环形队列中。 } } int main() { srand((uint64_t)time(nullptr) ^ getpid()); // 设置随机数种子，确保每次运行结果不同。 RingQueue<int> *rq = new RingQueue<int>(); // 创建一个RingQueue对象。 pthread_t c[3], p[2]; // 定义线程ID数组，3个消费者和2个生产者。 // 创建消费者线程。 pthread_create(&c[0], nullptr, consumer, (void*)rq); pthread_create(&c[1], nullptr, consumer, (void*)rq); pthread_create(&c[2], nullptr, consumer, (void*)rq); // 创建生产者线程。 pthread_create(&p[0], nullptr, productor, (void*)rq); pthread_create(&p[1], nullptr, productor, (void*)rq); // 等待所有线程完成。 for(int i = 0; i < 3; i++) pthread_join(c[i], nullptr); for(int i = 0; i < 2; i++) pthread_join(p[i], nullptr); return 0; // 程序结束。 }
首先通过srand()设置随机数种子，以确保每次程序运行时生成的随机数序列不同。然后，它创建了一个RingQueue<int>对象，用于存储生产者线程生成的整数。
接着，代码创建了3个消费者线程和2个生产者线程。每个线程都被分配了一个工作函数：生产者调用productor函数，而消费者调用consumer函数。这些线程通过pthread_create函数创建，并将RingQueue对象作为参数传递给它们的工作函数。
最后，main函数使用pthread_join等待所有线程完成，以确保程序在所有线程都执行完毕后才退出。
温馨提示
感谢您对博主文章的关注与支持！如果您喜欢这篇文章，可以点赞、评论和分享给您的同学，这将对我提供巨大的鼓励和支持。另外，我计划在未来的更新中持续探讨与本文相关的内容。我会为您带来更多关于Linux以及C++编程技术问题的深入解析、应用案例和趣味玩法等。如果感兴趣的话可以关注博主的更新，不要错过任何精彩内容！
再次感谢您的支持和关注。我们期待与您建立更紧密的互动，共同探索Linux、C++、算法和编程的奥秘。祝您生活愉快，排便顺畅！
