volatile和read应该是互斥的

假设我正在设计一个线程安全的类来包装一个内部集合:

public class ThreadSafeQueue<T>
{
    private readonly Queue<T> _queue = new Queue<T>();
    public void Enqueue(T item)
    {
        lock (_queue)
        {
            _queue.Enqueue(item);
        }
    }
    // ...
}

基于我的另一个问题，上面的实现是有bug的，因为当它的初始化与它的使用同时执行时，可能会出现竞争危险:

ThreadSafeQueue<int> tsqueue = null;
Parallel.Invoke(
    () => tsqueue = new ThreadSafeQueue<int>(),
    () => tsqueue?.Enqueue(5));

上面的代码是可以接受的不确定性:项可以排队，也可以不排队。然而，在当前的实现下，它也被打破了，并且可能产生不可预测的行为，例如抛出IndexOutOfRangeException, NullReferenceException，多次排队相同的项目，或者陷入无限循环。这是因为Enqueue调用可能在新实例被分配给局部变量tsqueue之后运行，但是在内部_queue字段的初始化完成(或似乎完成)之前运行。

Per Jon Skeet:

Java内存模型不能确保在将对新对象的引用分配给实例之前构造函数完成。Java内存模型在1.5版进行了重做，但是在没有volatile变量(c# 中的)的情况下，双重检查锁定仍然被打破。

可以通过在构造函数中添加内存屏障来解决这个竞争危险:

    public ThreadSafeQueue()
    {
        Thread.MemoryBarrier();
    }

同样，可以通过将字段设置为volatile来更简洁地解决这个问题:

    private volatile readonly Queue<T> _queue = new Queue<T>();

但是，后者是c#编译器禁止的:

'Program.ThreadSafeQueue<T>._queue': a field cannot be both volatile and readonly

考虑到以上似乎是volatile readonly的合理用例，这个限制是语言设计中的缺陷吗?

我知道可以简单地删除readonly，因为它不会影响类的公共接口。然而，这是无关紧要的，因为一般来说readonly也是如此。我也意识到存在的问题"为什么只读和volatile修饰符是互斥的?";然而，这解决了一个不同的问题。

具体场景:这个问题似乎影响了。net框架类库本身的System.Collections.Concurrent命名空间中的代码。ConcurrentQueue<T>.Segment嵌套类有几个只在构造函数中分配的字段:m_array、m_state、m_index和m_source。其中，只有m_index被声明为只读;其他的不能——尽管它们应该——因为它们需要被声明为volatile来满足线程安全的要求。

private class Segment
{
    internal volatile T[] m_array;                  // should be readonly too
    internal volatile VolatileBool[] m_state;       // should be readonly too
    private volatile Segment m_next;
    internal readonly long m_index; 
    private volatile int m_low;
    private volatile int m_high; 
    private volatile ConcurrentQueue<T> m_source;   // should be readonly too
    internal Segment(long index, ConcurrentQueue<T> source)
    {
        m_array = new T[SEGMENT_SIZE];              // field only assigned here
        m_state = new VolatileBool[SEGMENT_SIZE];   // field only assigned here
        m_high = -1;
        m_index = index;                            // field only assigned here
        m_source = source;                          // field only assigned here
    }
    internal void Grow()
    {
        // m_index and m_source need to be volatile since race hazards
        // may otherwise arise if this method is called before
        // initialization completes (or appears to complete)
        Segment newSegment = new Segment(m_index + 1, m_source);
        m_next = newSegment;
        m_source.m_tail = m_next;
    }
    // ...
}