单写多读场景下C#泛型结构体是否具备线程安全性？

使用场景 #

• 单个线程通过SetData()写入数据
• 多个线程可通过GetData()读取数据
• 泛型参数T仅为基础数据类型或结构体

待验证的C#泛型结构体 #

public struct ThreadSafeData<T>
{
    private T[] dataArray;

    private int setterIndex;        
    private int lastSetIndex;

    public void Init()
    {
        dataArray = new T[2];
    }

    public void SetData(T data)
    {
        dataArray[setterIndex] = data;            
        lastSetIndex = setterIndex;

        // 将0转为1，1转为0
        setterIndex = lastSetIndex * -1 + 1;
    }

    public T GetData()
    {            
        return dataArray[lastSetIndex];
    }
}

更新说明 #

我希望避免数据撕裂，确保读取线程总能获取写入线程的最新值。此前使用单个T字段时出现了数据撕裂问题，例如测试中写入Vector2Int的(0,0)或(1,1)，但读取线程有时会读到(1,0)，因此改用数组实现，并在测试中加入数据完整性校验。当前使用X64架构，测试所用Vector2Int为Unity官方类型。

测试情况 #

在Unity游戏开发环境中：

• 写入线程以30/60/90fps运行，每帧最多写入300次
• 读取线程以30-300fps运行，每帧读取1次
• 测试数据为包含Vector2Int和bool的结构体，读取线程校验规则：当bool为true时Vector2Int的x、y需均为1；当bool为false时x、y需均为0，不符合则抛出错误。

核心问题 #

1. 如何确认该实现是否确实线程安全？已运行测试约1小时未报错，但无法确定是否始终有效。
2. 针对该场景是否有更优的实现方案？

1. 当前实现的线程安全性分析 #

你的实现不能保证绝对线程安全，核心问题如下：

• 缺乏可见性保障：lastSetIndex的读写没有同步机制，读取线程可能读取到该变量的缓存旧值，导致获取数组中过时的数据。
• 指令重排风险：CPU或JIT编译器可能对SetData中的指令重排，比如先更新lastSetIndex再写入dataArray[setterIndex]，会让读取线程读到未完全写入的脏数据。
• 结构体赋值原子性限制：.NET中仅大小≤8字节的类型赋值是原子操作，像Vector2Int（12字节）或更大的自定义结构体，写入数组槽位的过程是非原子的，依然可能出现数据撕裂。

测试1小时无报错只能说明当前测试条件下未触发问题，但线程安全问题具有随机性，可能在高负载、不同硬件或JIT优化等级下才会暴露，不能以此证明绝对安全。

2. 更优的实现方案 #

针对单写多读的场景，推荐以下几种可靠方案：

方案一：Volatile+内存屏障实现双槽位无锁同步 #

通过Volatile保障变量可见性，结合内存屏障阻止指令重排，确保写入完成后再对外暴露数据：

public struct ThreadSafeData<T> where T : struct
{
    private T[] _dataArray;
    private volatile int _lastSetIndex;
    private int _setterIndex;

    public void Init()
    {
        _dataArray = new T[2];
        _lastSetIndex = 0;
        _setterIndex = 1;
    }

    public void SetData(T data)
    {
        // 先写入备用槽位
        _dataArray[_setterIndex] = data;
        // 内存屏障：确保数据写入完成后再更新索引
        Thread.MemoryBarrier();
        // 原子更新最新索引，保障可见性
        Interlocked.Exchange(ref _lastSetIndex, _setterIndex);
        // 切换下一次写入的槽位
        _setterIndex = _setterIndex == 0 ? 1 : 0;
    }

    public T GetData()
    {
        // 读取最新索引时强制获取最新值
        var index = Volatile.Read(ref _lastSetIndex);
        return _dataArray[index];
    }
}

核心优势：既避免了数据撕裂，又通过无锁设计保证了读写性能，适配所有结构体类型。

方案二：利用ConcurrentQueue简化实现 #

如果场景允许最终一致的最新值，可借助.NET内置的线程安全集合简化代码：

public struct ThreadSafeData<T> where T : struct
{
    private readonly ConcurrentQueue<T> _queue;

    public ThreadSafeData()
    {
        _queue = new ConcurrentQueue<T>();
    }

    public void SetData(T data)
    {
        _queue.Enqueue(data);
        // 只保留最新的一个值，清理旧数据
        while (_queue.Count > 1)
        {
            _queue.TryDequeue(out _);
        }
    }

    public T GetData()
    {
        _queue.TryPeek(out var data);
        return data;
    }
}

优缺点：代码简洁无需手动处理同步，但写入时存在轻微性能开销，极端情况下可能读取到稍旧的值（符合单写多读的最终一致性需求）。

方案三：AtomicReference适配大结构体 #

对于超大结构体，可使用AtomicReference实现原子性的引用更新：

public struct ThreadSafeData<T> where T : struct
{
    private AtomicReference<ReadOnlyMemory<T>> _dataRef;

    public void Init(T initialData)
    {
        _dataRef = new AtomicReference<ReadOnlyMemory<T>>(new ReadOnlyMemory<T>(new[] { initialData }));
    }

    public void SetData(T data)
    {
        var newMemory = new ReadOnlyMemory<T>(new[] { data });
        _dataRef.Value = newMemory;
    }

    public T GetData()
    {
        return _dataRef.Value.Span[0];
    }
}

核心优势：AtomicReference的赋值是原子操作且保障可见性，读取线程总能拿到完整的最新数据。

验证线程安全的有效方法 #

要确认实现的可靠性，不能仅依赖手动测试，还需：

• 高并发压力测试：用Task.Run启动数十个读取线程，持续运行数小时模拟极端场景
• 内存模型合规性检查：确保所有共享变量的读写都符合.NET内存模型（使用Volatile、Interlocked或内存屏障）
• 反编译验证：通过工具查看JIT编译后的代码，确认无危险指令重排
• 官方文档参考：明确.NET中类型赋值的原子性规则（仅≤8字节类型为原子操作）

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