无锁环形缓冲区通过原子操作实现线程安全，使用读写索引避免互斥锁，适用于单生产者单消费者场景，以预留一个空槽解决满/空判断歧义，结合适当内存序保证正确性与性能。
实现一个无锁环形缓冲区（Lock-Free Ring Buffer）的关键在于利用原子操作保证线程安全，同时避免使用互斥锁来提升并发性能。这种结构常用于高吞吐场景，比如日志系统、网络数据传输或实时消息队列。
基本设计思路
无锁环形缓冲区通常基于固定大小的数组实现，包含两个核心指针（或索引）：
- 写索引（write_index）：生产者用它标记下一个可写位置
- 读索引（read_index）：消费者用它标记下一个可读位置
所有对索引的访问都通过std::atomic完成，确保多线程环境下的一致性。
关键约束与优化
为了避免读写冲突并简化逻辑，常用策略是预留一个“空槽”：
立即学习“C++免费学习笔记（深入）”；
- 当 (write_index + 1) % capacity == read_index 时，认为缓冲区已满
- 当 write_index == read_index 时，缓冲区为空
这意味着实际可用容量为 N-1（N 是底层数组大小）。
C++ 实现示例
以下是一个线程安全、单生产者单消费者（SPSC）场景下的无锁环形缓冲区实现：
#include <atomic>
#include <vector>
template <typename T>
class LockFreeRingBuffer {
private:
std::vector<T> buffer;
std::atomic<size_t> write_index{0};
std::atomic<size_t> read_index{0};
size_t capacity;
public:
explicit LockFreeRingBuffer(size_t size)
: buffer(size), capacity(size) {}
bool push(const T& item) {
size_t current_write = write_index.load(std::memory_order_relaxed);
size_t next_write = (current_write + 1) % capacity;
if (next_write == read_index.load(std::memory_order_acquire)) {
return false; // 已满
}
buffer[current_write] = item;
write_index.store(next_write, std::memory_order_release);
return true;
}
bool pop(T& item) {
size_t current_read = read_index.load(std::memory_order_relaxed);
if (current_read == write_index.load(std::memory_order_acquire)) {
return false; // 已空
}
item = buffer[current_read];
size_t next_read = (current_read + 1) % capacity;
read_index.store(next_read, std::memory_order_release);
return true;
}
bool empty() const {
return read_index.load() == write_index.load();
}
};
内存序（Memory Order）说明
上面代码中使用了不同的内存序来平衡性能与正确性：
- std::memory_order_relaxed：用于本地计算，不涉及同步
- std::memory_order_acquire：在 load 时确保后续读操作不会重排到其前面
- std::memory_order_release：在 store 时确保之前的所有写操作已完成
这对 SPSC 场景足够安全。若扩展到多生产者或多消费者，则需更复杂的同步机制（如 CAS 循环），性能也会下降。
基本上就这些。只要控制好并发模型，无锁环形缓冲区能提供极低延迟和高吞吐的数据传递能力。
