Linux-c++消息缓存机制

#include <list>
std ::list<int> lisMsg;
void sendListMsg()
{
    lisMsg.push_back(1);
    lisMsg.push_back(3);
    lisMsg.push_back(7);
    lisMsg.push_back(5);
    lisMsg.push_back(9);
    lisMsg.push_back(2);
    lisMsg.push_back(15);
    lisMsg.push_back(18);
    std::cout << "*******开始【发送】消息元素*****" << endl;
    for (int n : lisMsg)
    {
        std::cout << "list-发送元素：" << n << endl;
    }
}
void getListMsg()
{
    std::cout << "----开始【获取】消息元素----" << endl;
    while (!lisMsg.empty())
    {
        std::cout << "list-获取元素：" << lisMsg.front() << endl;
        lisMsg.pop_front();
    }
    std::cout << "----开始【检查】消息元素----" << endl;
    if (!lisMsg.empty())
    {
        // 检查 处理消息的逻辑
        std::cout << "检查 处理消息 还有没有完成！！！ " << std::endl;
    }
    else
    {
        std::cout << "检查 处理消息 No messages in the cache." << std::endl;
    }
}

*******开始【发送】消息元素*****
list-发送元素：1
list-发送元素：3
list-发送元素：7
list-发送元素：5
list-发送元素：9
list-发送元素：2
list-发送元素：15
list-发送元素：18
----开始【获取】消息元素----
list-获取元素：1
list-获取元素：3
list-获取元素：7
list-获取元素：5
list-获取元素：9
list-获取元素：2
list-获取元素：15
list-获取元素：18
----开始【检查】消息元素----
检查 处理消息 No messages in the cache.

线程安全应用

#include <condition_variable>
#include <iostream>
#include <queue>
#include <thread>

std::mutex mytx;
std::condition_variable cv;

class Message {
    std::queue<std::string> messageCache;

  public:
    void pushMsg() {
        std::lock_guard<std::mutex> lock(mytx);
        std::cout << "*******开始【发送】消息元素*****" << std::endl;
        for (int i = 0; i < 10; i++) {
            messageCache.push("missage= " + std::to_string(i));
            std::cout << "获取发送元素：" << std::to_string(i) << std::endl;
        }
        cv.notify_one();
    }

  public:
    std::string popMsg() {
        std::string message = messageCache.front();
        // 处理消息的逻辑
        std::cout << "Processing message:-->  " << message << std::endl;
        messageCache.pop();
        return message;
    }

  public:
    bool isEmpty() { 
        return messageCache.empty(); }
};

Message msg;
void produceMessage() { msg.pushMsg(); }

void processMessage() {
    std::unique_lock<std::mutex> lock(mytx);
    bool bb = !msg.isEmpty();
    std::cout << "----开始【获取】消息元素----" << std::to_string(bb)
              << std::endl;
    cv.wait(lock, []() { return !msg.isEmpty(); });

    while (!msg.isEmpty()) {
        std::string message = msg.popMsg();
        // 处理消息的逻辑
        // std::cout << "Processing message:-->  " << message << std::endl;
    }
    std::cout << "----开始【检查】消息元素----" << std::endl;
    if (!msg.isEmpty()) {
        // 检查 处理消息的逻辑
        std::cout << "检查 处理消息 还有没有完成！！！ " << std::endl;
    } else {
        std::cout << "检查 处理消息 No messages in the cache." << std::endl;
    }
}

int main() {
    std::thread t1(produceMessage);
    std::thread t2(processMessage);
    t1.join();
    t2.join();

    // produceMessage();
    // processMessage(); // 处理并删除第一个消息
    return 0;
}


开始运行...

*******开始【发送】消息元素*****
获取发送元素：0
获取发送元素：1
获取发送元素：2
获取发送元素：3
获取发送元素：4
获取发送元素：5
获取发送元素：6
获取发送元素：7
获取发送元素：8
获取发送元素：9
----开始【获取】消息元素----1
Processing message:-->  missage= 0
Processing message:-->  missage= 1
Processing message:-->  missage= 2
Processing message:-->  missage= 3
Processing message:-->  missage= 4
Processing message:-->  missage= 5
Processing message:-->  missage= 6
Processing message:-->  missage= 7
Processing message:-->  missage= 8
Processing message:-->  missage= 9
----开始【检查】消息元素----
检查 处理消息 No messages in the cache.

运行结束。

环形缓冲区： 适用于需要固定大小缓存的场景，可以避免动态内存分配。实现示例：

#include <vector>
#include <iostream>

class RingBuffer {
public:
    RingBuffer(size_t size) : buffer(size), head(0), tail(0), full(false) {}

    void push(int value) {
        buffer[tail] = value;
        if (full) {
            head = (head + 1) % buffer.size();
        }
        tail = (tail + 1) % buffer.size();
        full = (tail == head);
    }

    int pop() {
        if (empty()) {
            throw std::runtime_error("Buffer is empty");
        }
        int value = buffer[head];
        full = false;
        head = (head + 1) % buffer.size();
        return value;
    }

    bool empty() const {
        return (!full && (head == tail));
    }

private:
    std::vector<int> buffer;
    size_t head, tail;
    bool full;
};