【Linux】基于环形队列RingQueue的生产消费者模型

环形队列（RingQueue）是一种特殊的队列，其操作方式与普通队列类似，但其内部实现是一个循环数组。下面是一个简单的基于环形队列的生产者-消费者模型的示例代码：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
 
template<typename T>
class RingQueue {
private:
    std::vector<T> buffer;
    size_t head = 0;
    size_t tail = 0;
    size_t capacity;
    std::mutex mtx;
    std::condition_variable cond_prod;
    std::condition_variable cond_cons;
 
public:
    RingQueue(size_t size) : capacity(size), buffer(size) {}
 
    void enqueue(const T& item) {
        std::unique_lock<std::mutex> lock(mtx);
        while ((tail + 1) % capacity == head) {
            cond_prod.wait(lock);
        }
        buffer[tail] = item;
        tail = (tail + 1) % capacity;
        lock.unlock();
        cond_cons.notify_one();
    }
 
    T dequeue() {
        std::unique_lock<std::mutex> lock(mtx);
        while (head == tail) {
            cond_cons.wait(lock);
        }
        T item = buffer[head];
        head = (head + 1) % capacity;
        lock.unlock();
        cond_prod.notify_one();
        return item;
    }
};
 
void producer(RingQueue<int>& queue) {
    for (int i = 0; i < 10; ++i) {
        queue.enqueue(i);
        std::cout << "Produced: " << i << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}
 
void consumer(RingQueue<int>& queue) {
    int data;
    while (true) {
        data = queue.dequeue();
        if (data >= 10) break;
        std::cout << "Consumed: " << data << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }
}
 
int main() {
    RingQueue<int> queue(5);
 
    std::thread producer_thread(producer, std::ref(queue));
    std::thread consumer_thread(consumer, std::ref(queue));
 
    producer_thread.join();
    consumer_thread.join();
 
    return 0;
}

这段代码首先定义了一个模板类RingQueue，它包含了环形队列的基本操作，如入队和出队。然后，我们创建了生产者和消费者线程，分别执行producer和consumer函数，它们通过RingQueue进行通信。这个例子展示了如何使用条件变量和互斥锁来同步生产者和消费者的动作。