如何在双共享内存监听处理场景中降低CPU占用率？

1. 改造共享内存接收器为阻塞式等待 #

当前CPU占用过高的核心原因是线程在无数据时仍持续空转调用Recv。如果能让Recv在无数据时自动阻塞，直到有新数据到来再唤醒线程，就能让线程进入休眠状态，彻底消除空转消耗。

实现思路是在共享内存接收器内部加入同步机制（如条件变量、信号量），生产者写入数据后主动通知等待的线程：

class ShmReceiver {
private:
    std::mutex mtx;
    std::condition_variable cv;
    std::queue<std::string> data_queue;
    // 其他共享内存底层成员

public:
    // 阻塞式接收：无数据时休眠，有数据时立即返回
    void Recv(std::string* s) {
        std::unique_lock<std::mutex> lock(mtx);
        // 等待直到队列有数据
        cv.wait(lock, [this](){ return !data_queue.empty(); });
        *s = data_queue.front();
        data_queue.pop();
    }

    // 生产者调用的写入方法，写入后唤醒等待线程
    void Send(const std::string& data) {
        std::lock_guard<std::mutex> lock(mtx);
        data_queue.push(data);
        cv.notify_one();
    }
};

这种方式完全保留了线程独立处理的非阻塞特性，同时CPU占用会降到接近0（仅在处理数据时占用）。

2. 非阻塞Recv间隙加入短暂休眠 #

如果无法修改Recv的实现（比如使用第三方库），可以在轮询失败（无数据）时让线程短暂休眠，减少空转频率：

void RunFirst() {
  while (true) {
    std::string s;
    // 假设Recv返回bool表示是否成功获取数据
    if (shm1_->Recv(&s)) { 
      // handle 1
    } else {
      // 休眠1ms，可根据业务延迟要求调整时长
      std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
  }
}

该方法简单易实现，但存在 trade-off：休眠时长越长，CPU占用越低，但数据处理延迟可能越高，需要根据业务场景平衡调整。

3. 使用IO多路复用合并监听逻辑 #

利用Linux的epoll、Windows的IOCP等多路复用机制，用单个线程同时监听多个共享内存的事件，避免多线程空转。前提是共享内存可以关联到文件描述符（比如基于内存映射文件实现，或同步信号量绑定fd）：

void RunShmListeners() {
    int epfd = epoll_create1(0);
    // 假设每个ShmReceiver提供事件fd（比如信号量fd或自定义事件fd）
    struct epoll_event ev1, ev2;
    ev1.events = EPOLLIN;
    ev1.data.fd = shm1_->GetEventFd();
    epoll_ctl(epfd, EPOLL_CTL_ADD, shm1_->GetEventFd(), &ev1);

    ev2.events = EPOLLIN;
    ev2.data.fd = shm2_->GetEventFd();
    epoll_ctl(epfd, EPOLL_CTL_ADD, shm2_->GetEventFd(), &ev2);

    struct epoll_event events[2];
    while (true) {
        // 阻塞直到有事件触发
        int nfds = epoll_wait(epfd, events, 2, -1); 
        for (int i = 0; i < nfds; ++i) {
            if (events[i].data.fd == shm1_->GetEventFd()) {
                std::string s;
                shm1_->Recv(&s);
                // handle 1
            } else if (events[i].data.fd == shm2_->GetEventFd()) {
                std::string s;
                shm2_->Recv(&s);
                // handle 2
            }
        }
    }
    close(epfd);
}

这种方式用单线程高效处理多源事件，CPU占用极低，且无额外延迟。

4. 基于信号驱动的唤醒机制 #

让数据写入进程在完成写入后，向监听进程发送特定信号（如SIGUSR1），监听线程在无数据时休眠，收到信号后再处理数据：

#include <signal.h>
#include <atomic>

std::atomic<bool> shm1_has_data(false);
std::atomic<bool> shm2_has_data(false);

void shm1_signal_handler(int) {
    shm1_has_data = true;
}

void shm2_signal_handler(int) {
    shm2_has_data = true;
}

void RunFirst() {
    signal(SIGUSR1, shm1_signal_handler);
    while (true) {
        // 休眠直到收到信号
        pause(); 
        if (shm1_has_data) {
            std::string s;
            shm1_->Recv(&s);
            // handle 1
            shm1_has_data = false;
        }
    }
}

此方案需要写入端配合实现信号发送，适合对延迟敏感且无法修改共享内存接收器的场景。

内容的提问来源于stack exchange，提问作者nothingisme