c++如何实现一个高效的环形缓冲区_c++ Ring Buffer数据结构【源码】-C++-PHP中文网

c++如何实现一个高效的环形缓冲区_c++ Ring Buffer数据结构【源码】

冰火之心

发布： 2025-12-22 17:39:08

原创

875人浏览过

该环形缓冲区采用SPSC无锁设计，利用原子变量与内存序保证线程安全，通过mask位运算加速索引回绕，支持2的幂容量优化及非2幂兼容，兼顾性能、正确性与扩展性。

c++如何实现一个高效的环形缓冲区_c++ ring buffer数据结构【源码】

用 C++ 实现一个高效的环形缓冲区（Ring Buffer），核心在于避免内存拷贝、支持无锁读写（单生产者/单消费者场景下）、利用模运算或位运算做索引回绕，并兼顾线程安全与缓存友好性。下面是一个轻量、实用、可直接使用的模板实现，支持自动扩容（可选）、线程安全控制（通过模板参数开关），并附关键设计说明。

基础模板实现（SPSC，单生产者单消费者）

这是最高效、最常用的形式，无需锁，靠原子变量 + 内存序保证可见性：

#include <atomic>
#include <cstddef>
#include <vector>
#include <utility>
<p>template <typename T>
class RingBuffer {
static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");</p><pre class='brush:php;toolbar:false;'>std::vector<T> buffer_;
std::atomic<size_t> head_{0};  // 生产者写入位置（下一个空槽）
std::atomic<size_t> tail_{0};  // 消费者读取位置（下一个有效数据）

const size_t capacity_;
const size_t mask_;  // 若容量为2的幂，可用 mask = capacity_ - 1，加速取模

登录后复制

public: explicit RingBuffer(sizet capacity) : buffer(capacity), capacity(capacity), mask((capacity & (capacity-1)) == 0 ? capacity-1 : 0) {}

// 入队：返回 false 表示满
bool push(const T& item) {
    const size_t h = head_.load(std::memory_order_acquire);
    const size_t t = tail_.load(std::memory_order_acquire);
    const size_t size = (h - t) & (mask_ ? mask_ : capacity_ - 1); // 容量非2幂时用常规模
    if (size == capacity_ - 1) return false; // 留1空位避免 head==tail 的歧义（满/空难区分）

    buffer_[h & mask_] = item;
    head_.store(h + 1, std::memory_order_release);
    return true;
}

// 出队：返回 false 表示空
bool pop(T& item) {
    const size_t t = tail_.load(std::memory_order_acquire);
    const size_t h = head_.load(std::memory_order_acquire);
    if (t == h) return false;

    item = buffer_[t & mask_];
    tail_.store(t + 1, std::memory_order_release);
    return true;
}

size_t size() const {
    const size_t h = head_.load(std::memory_order_acquire);
    const size_t t = tail_.load(std::memory_order_acquire);
    return (h - t) & (mask_ ? mask_ : capacity_ - 1);
}

bool empty() const { return size() == 0; }
bool full() const { return size() == capacity_ - 1; }

登录后复制

};

为什么用 mask 而不是 % 运算？

当容量是 2 的整数次幂（如 1024、4096）时，index & mask 等价于 index % capacity，但前者是位运算，零开销，CPU 友好。编译器通常无法对 % 自动优化成 &，除非明确知道 capacity 是 2 幂 —— 所以建议构造时检查并缓存 mask。

立即学习“C++免费学习笔记（深入）”；

腾讯智影

腾讯推出的在线智能视频创作平台

341

查看详情

构造时判断：if ((capacity & (capacity-1)) == 0) 即为 2 幂
非 2 幂容量也可工作，只是回绕用 (h - t) % capacity（注意处理负数，推荐用 (h - t + capacity) % capacity）
实际项目中优先选用 2 幂容量，兼顾性能与通用性

线程安全扩展（MPMC 场景）

多生产者多消费者需加锁或更复杂原子操作（如双原子 CAS）。简单可靠的做法是封装 mutex：

template <typename T, bool ThreadSafe = false>
class RingBuffer {
    // ... 成员同上 ...
private:
    mutable std::mutex mtx_;
<p>public:
template <bool TS = ThreadSafe>
std::enable_if_t<TS, bool> push(const T& item) {
std::lock<em>guard<std::mutex> lk(mtx</em>);
return push_unlocked(item);
}</p><pre class='brush:php;toolbar:false;'>template <bool TS = ThreadSafe>
std::enable_if_t<!TS, bool> push(const T& item) {
    return push_unlocked(item);
}

登录后复制

private: bool push_unlocked(const T& item) { / 原 push 逻辑 / } };