基于3元素缓冲区的无锁多线程读写方案可行性及相关问题咨询

我有一个数据源，每15至20毫秒生成一个PointF类型的数据；而我需要每10毫秒读取并存储这些数据。为此我设计了一个包含3个元素的缓冲区，通过指针实现无锁访问，代码如下：

protected class PosBuffer
{
    PointF[] m_Buffer = new PointF[3];
    volatile int m_ReadPointer = 0;
    volatile int m_WritePointer = 1;
    internal PosBuffer()
    {
        m_Buffer[0] = new PointF(0, 0);
        m_Buffer[1] = new PointF(0, 0);
        m_Buffer[2] = new PointF(0, 0);
    }

    internal void Write(PointF point)
    {
        m_Buffer[m_WritePointer] = point;
        m_ReadPointer++;
        if (m_ReadPointer == 3) m_ReadPointer = 0;
        m_WritePointer++;
        if (m_WritePointer == 3) m_WritePointer = 0;
    }

    internal PointF Read()
    {
        return m_Buffer[m_ReadPointer];
    }
}

我的设计思路如下：

• 新数据到达时写入当前写指针指向的位置，随后将读指针指向该位置，再递增写指针；
• 若无新数据生成，消费者线程将重复读取旧数据；
• 该结构支持读写速率不一致的场景。

现咨询以下技术问题：

1. 该方案是否可行？
2. 是否需要使用锁、监视器、临界区等同步机制？
3. 是否需要禁用编译器优化？
4. 是否有更优的已知解决方案？

1. 该方案是否可行？ #

基本可行，但存在潜在风险。
从速率匹配来看，数据源15-20ms产生一个数据，消费者10ms读一次，3个元素的缓冲区完全能覆盖读写速率差，不会出现数据覆盖情况——写操作频率低于读操作，每次写只会更新一个位置，读指针会同步到最新写入位置，旧数据即使没读完也不影响，消费者需要最新数据时能自动获取。
但要注意：PointF是8字节值类型，32位系统下它的赋值不是原子操作，可能出现消费者读取到半更新的值（比如X是新值、Y是旧值）；64位系统下8字节赋值是原子的，不会有这个问题。

2. 是否需要使用锁、监视器、临界区等同步机制？ #

不需要传统锁，但要处理值类型原子性问题。
若运行在64位系统，PointF赋值是原子的，加上你用volatile修饰了指针，已保证指针的可见性，此时不需要额外锁。但如果是32位系统，必须保证PointF写入原子性，可通过两种方式解决：

• 把PointF包装成引用类型（比如自定义PointWrapper类），引用类型的赋值是原子的；
• 用Interlocked类的方法实现原子写入（比如将结构体转换为IntPtr后用Interlocked.Exchange，但实现较繁琐）。

另外，volatile已经保证了指针读写的内存可见性，不会出现线程读取缓存旧指针值的情况，所以不需要锁来同步指针操作。

3. 是否需要禁用编译器优化？ #

不需要。
你用volatile修饰了m_ReadPointer和m_WritePointer，这个关键字会告诉编译器和CPU，不要对这些变量的读写进行重排序或缓存优化，能保证变量的可见性和操作顺序。对于m_Buffer的访问，因为指针是volatile的，编译器不会将指针读取和缓冲区访问非法重排序，所以不需要全局禁用编译器优化。

4. 是否有更优的已知解决方案？ #

有几种更成熟的方案可选：

（1）直接用单变量存储最新值 #

你的需求本质是消费者读取最新可用数据，不需要保留历史数据，完全可以不用缓冲区，直接用volatile变量存储：

private volatile PointF _latestPoint;

public void Write(PointF point)
{
    _latestPoint = point;
}

public PointF Read()
{
    return _latestPoint;
}

同样要注意32位系统下的原子性问题，解决方式同上。这种方案比缓冲区更简单高效，完全满足需求。

（2）标准无锁环形缓冲区/ConcurrentQueue #

如果后续需要保留历史数据，或者有多个生产者/消费者场景，可以用标准无锁环形缓冲区实现。若需要按顺序处理所有数据，.NET自带的ConcurrentQueue是现成的线程安全实现，无需自己造轮子。

（3）用Memory优化缓冲区（可选） #

如果坚持用缓冲区，在现代.NET中可以用Memory<PointF>替代数组，API更灵活，但核心逻辑和你的设计一致。

内容的提问来源于stack exchange，提问作者M. Enke