多线程共享ConcurrentQueue，仅取消费者线程最新值的实现疑问

你的核心需求是在高实时性场景下，输出线程仅获取输入线程产生的最新数据，原有的ConcurrentQueue方案存在两个明显问题：一是无法直接获取队尾最新值，遍历清空队列会额外增加延迟；二是你自定义的ConcurrentQueueWithLast存在线程安全隐患。

自定义类的线程安全隐患 #

你编写的ConcurrentQueueWithLast有三个关键问题：

1. 可见性缺失：lastElement字段没有线程可见性保障。输入线程更新该字段后，输出线程可能因CPU缓存优化无法立即读取到最新值，导致拿到旧数据。
2. 数据不一致：Enqueue方法中，queue.Enqueue是线程安全的，但lastElement = item的赋值无同步机制。若输入线程在执行完入队操作后、赋值前被中断，输出线程此时读取Last会拿到旧值，但队列中已存在新数据，引发数据不一致。
3. 内存浪费：输入流速度快于输出流时，队列会持续积累大量无用的旧数据，占用额外内存资源。

最优解决方案：抛弃队列，直接维护最新值 #

既然你只需要最新数据、无需保留历史，完全可以去掉ConcurrentQueue，用更轻量的线程安全结构维护最新值，既避免队列开销，又保证低延迟。

方案1：使用volatile（适合引用类型） #

如果RigidBodyData是引用类型，用volatile修饰字段保证线程可见性：

public class LatestRigidBodyDataHolder
{
    // volatile确保字段更新对所有线程立即可见
    private volatile RigidBodyData _latestData;

    public void Update(RigidBodyData newData)
    {
        // 若需避免引用共享，可在此处复制新数据（值类型无需复制，引用类型按需深拷贝）
        _latestData = newData;
    }

    public RigidBodyData GetLatest()
    {
        return _latestData;
    }
}

方案2：使用lock（适合值类型） #

如果RigidBodyData是值类型（struct），volatile无法直接使用，可选择lock——现代CPU的lock开销极低，完全满足低延迟要求：

public struct RigidBodyData { /* 你的结构体定义 */ }

public class LatestRigidBodyDataHolder
{
    private RigidBodyData _latestData;
    private readonly object _lockObj = new object();

    public void Update(RigidBodyData newData)
    {
        lock (_lockObj)
        {
            _latestData = newData;
        }
    }

    public RigidBodyData GetLatest()
    {
        lock (_lockObj)
        {
            return _latestData;
        }
    }
}

若必须保留队列（如偶尔需回溯历史） #

如果你确实需要保留队列，可修改自定义类解决线程安全问题：

public class ConcurrentQueueWithLast<T>
{
    private readonly ConcurrentQueue<T> _queue = new ConcurrentQueue<T>();
    private volatile T _lastElement;
    private readonly object _clearLock = new object();

    public void Enqueue(T item)
    {
        _queue.Enqueue(item);
        // volatile保证最新值立即可见
        _lastElement = item;
    }

    // 获取最新值并清空队列（线程安全）
    public bool TryGetLatestAndClear(out T latest)
    {
        lock (_clearLock)
        {
            latest = _lastElement;
            // 清空队列，丢弃所有旧数据
            while (_queue.TryDequeue(out _)) { }
            // 清空后若有新元素入队，_lastElement已更新为最新值，无需额外处理
            return !EqualityComparer<T>.Default.Equals(latest, default);
        }
    }

    // 保留原有方法（按需使用）
    public bool TryDequeue(out T result) => _queue.TryDequeue(out result);
    public bool TryPeek(out T result) => _queue.TryPeek(out result);
    public T Last => _lastElement;
}

修改点：

• 给_lastElement添加volatile保证可见性
• 新增TryGetLatestAndClear方法，用lock保证清空队列和获取最新值的原子性，避免并发冲突

总结 #

你的场景下，直接维护最新值的方案是最优选择，既消除了队列的内存开销，又保证了最低延迟和线程安全。若必须保留队列，再使用修改后的ConcurrentQueueWithLast类。

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