【Linux】生产者消费者模型

#include <iostream>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <random>
#include <chrono>

std::queue<int> queue_;
std::mutex mtx_;
std::condition_variable cv_;
bool stop_ = false;

void producer() {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(1, 100);

    while (!stop_) {
        std::unique_lock<std::mutex> lock(mtx_);
        cv_.wait(lock, [] { return queue_.size() < 10; });  // 当队列不满时生产
        int item = dis(gen);
        queue_.push(item);
        lock.unlock();
        cv_.notify_one();  // 通知消费者
        std::cout << "Produced: " << item << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(500));  // 模拟耗时操作
    }
}

void consumer() {
    while (!stop_) {
        std::unique_lock<std::mutex> lock(mtx_);
        cv_.wait(lock, [] { return !queue_.empty(); });  // 当队列不为空时消费
        int item = queue_.front();
        queue_.pop();
        lock.unlock();
        cv_.notify_one();  // 通知生产者
        std::cout << "Consumed: " << item << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));  // 模拟耗时操作
    }
}

int main() {
    std::thread prod(producer);
    std::thread cons(consumer);

    std::this_thread::sleep_for(std::chrono::seconds(5));  // 让生产者和消费者运行一段时间
    stop_ = true;  // 停止生产者和消费者
    cv_.notify_all();  // 唤醒所有等待的线程

    prod.join();
    cons.join();

    return 0;
}

在这个示例中，我们创建了一个阻塞队列queue_，并使用mtx_来保护对队列的访问。cv_是一个条件变量，用于在队列为空时阻塞消费者线程，以及在队列满时阻塞生产者线程。

生产者线程在每次生产数据前会检查队列的大小，如果队列已满则等待。当队列不满时，生产者会生成一个随机数并将其放入队列，然后通知一个等待的消费者线程。

消费者线程在每次消费数据前会检查队列是否为空，如果队列为空则等待。当队列不为空时，消费者会从队列中取出一个数据项并消费它，然后通知一个等待的生产者线程。

主线程在运行一段时间后设置stop_为true，以停止生产者和消费者线程的运行。然后，它使用cv_.notify_all()来唤醒所有等待的线程，确保它们能够正确地退出。最后，主线程等待生产者和消费者线程完成执行。

POSIX信号量

POSIX信号量在Linux中是一种关键的同步机制，用于协调多个进程或线程对共享资源的访问。它基于原子操作，确保了数据访问的一致性和正确性，同时提供了高效的进程间通信和同步能力。

POSIX信号量的特点和应用场景

进程同步：POSIX信号量允许进程在访问共享资源之前进行互斥和同步操作，避免数据竞争和冲突。
控制资源访问：信号量可以用于限制对资源的访问数量，确保资源的合理分配和使用。
进程间通信：通过信号量，进程之间可以实现有序的通信和协作，确保操作的顺序性和一致性。
高效性：POSIX信号量的实现通常基于硬件原子操作，具有高效的性能表现。

POSIX信号量的类型和操作

POSIX信号量分为有名信号量和无名信号量两种。有名信号量具有一个唯一的名字，不同进程可以通过相同的名字来操作信号量。无名信号量则用于同一进程内的线程间同步。

在操作方面，POSIX信号量主要包括P操作和V操作。P操作用于申请信号量，当信号量值大于0时，计数器减一并允许进程进入临界区；当信号量值为0时，进程将阻塞等待。V操作用于释放信号量，将计数器加一，并可能唤醒等待的进程。

通过这些操作，POSIX信号量能够有效地管理共享资源的访问，确保系统的稳定性和并发性能。

基于环形队列的生产者消费者模型

在C++中，我们可以使用数组和取模操作来实现一个环形队列（也称为循环队列）。以下是一个基于环形队列的生产者消费者模型的简单实现：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <random>
#include <chrono>

const int QUEUE_SIZE = 10;

class CircularQueue {
private:
    int front, rear;
    int queue[QUEUE_SIZE];
    std::mutex mtx;
    std::condition_variable cv;

public:
    CircularQueue() : front(0), rear(0) {}

    bool isFull() {
        return (rear + 1) % QUEUE_SIZE == front;
    }

    bool isEmpty() {
        return front == rear;
    }

    void enqueue(int item) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [this]{ return !isFull(); });
        queue[rear] = item;
        rear = (rear + 1) % QUEUE_SIZE;
        lock.unlock();
        cv.notify_one();
    }

    int dequeue() {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [this]{ return !isEmpty(); });
        int item = queue[front];
        front = (front + 1) % QUEUE_SIZE;
        lock.unlock();
        cv.notify_one();
        return item;
    }
};

void producer(CircularQueue& queue) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(1, 100);

    while (true) {
        int item = dis(gen);
        queue.enqueue(item);
        std::cout << "Produced: " << item << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
}

void consumer(CircularQueue& queue) {
    while (true) {
        int item = queue.dequeue();
        std::cout << "Consumed: " << item << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main() {
    CircularQueue queue;
    std::thread prod(producer, std::ref(queue));
    std::thread cons(consumer, std::ref(queue));

    prod.join();
    cons.join();

    return 0;
}

在这个例子中，我们定义了一个CircularQueue类来实现环形队列。enqueue方法用于向队列中添加元素，dequeue方法用于从队列中移除元素。我们使用std::mutex和std::condition_variable来实现线程同步。当队列满时，生产者线程会等待；当队列空时，消费者线程会等待。

producer函数模拟生产者线程，不断生成随机数并添加到队列中。consumer函数模拟消费者线程，不断从队列中取出并消费元素。

在main函数中，我们创建了一个CircularQueue对象，并启动了一个生产者线程和一个消费者线程。这两个线程将一直运行，直到程序被外部终止。