c# 如何在C#中实现一个无锁环形缓冲区（Ring Buffer）

来源：这里教程网时间：2026-02-21 17:36:08 作者：

为什么不能直接用

ConcurrentQueue<t></t>

代替环形缓冲区

因为

ConcurrentQueue<t></t>

是链表实现，内存不连续，无法保证写入/读取的原子性批次，也不支持预分配固定大小和零拷贝访问。环形缓冲区核心价值在于：确定容量、缓存友好、单生产者/单消费者（SPSC）场景下免锁、支持指针快速读写。如果你需要的是高吞吐低延迟的日志暂存、网络包收发或实时音频流缓冲，

ConcurrentQueue

的 GC 压力和间接寻址开销会成为瓶颈。

如何用

Interlocked

实现 SPSC 无锁环形缓冲区

关键不是“完全不用锁”，而是避免

lock

语句阻塞线程；SPSC 场景下，仅用

Interlocked.CompareExchange

和

Interlocked.Add

即可协调读写索引。必须满足：一个线程只写、一个线程只读，且不允许多对一或一对多。

缓冲区底层数组用
T[]
预分配，长度为 2 的幂（便于位运算取模）写索引（
_writeIndex
）和读索引（
_readIndex
）均为
long
类型，避免 32 位溢出导致误判实际位置用
index & (_capacity - 1)
计算，比
% _capacity
快且安全写操作前先用
Interlocked.CompareExchange
检查是否有足够空位，失败则返回
false
（不阻塞）读操作同理，检查是否有数据可读，再用
Interlocked.Add
批量推进读索引

public sealed class RingBuffer<T>
{
    private readonly T[] _buffer;
    private readonly int _capacity;
    private readonly int _mask;
    private long _writeIndex;
    private long _readIndex;
<pre class='brush:php;toolbar:false;'>public RingBuffer(int capacity)
{
    _capacity = RoundUpToPowerOfTwo(capacity);
    _mask = _capacity - 1;
    _buffer = new T[_capacity];
}
public bool TryWrite(T item)
{
    long writePos = Interlocked.Read(ref _writeIndex);
    long readPos = Interlocked.Read(ref _readIndex);
    long available = _capacity - (writePos - readPos);
    if (available <= 0) return false;
    _buffer[writePos & _mask] = item;
    Interlocked.Increment(ref _writeIndex);
    return true;
}
public bool TryRead(out T item)
{
    item = default!;
    long writePos = Interlocked.Read(ref _writeIndex);
    long readPos = Interlocked.Read(ref _readIndex);
    if (writePos == readPos) return false;
    item = _buffer[readPos & _mask];
    Interlocked.Increment(ref _readIndex);
    return true;
}
private static int RoundUpToPowerOfTwo(int v)
{
    v--;
    v |= v >> 1;
    v |= v >> 2;
    v |= v >> 4;
    v |= v >> 8;
    v |= v >> 16;
    return v + 1;
}

}

为什么