如果有人能够详细说明无序负载到负载可能会产生问题的逐步方案,我将不胜感激.也就是说,如果每个线程的加载顺序首先加载字段然后加载引用而不是我们期望的方式,那么使用该类并将引用及其字段分配给变量的两个或多个线程怎么可能是个问题呢？它是(首先加载参考,然后加载通过参考获得的字段的值)？

我知道这种情况很少发生(失败是因为无序加载).事实上,我可以看到一个线程可以在不知道引用值(指针？)是什么的情况下首先错误地读取字段的值,但如果发生这种情况,那么该线程将自行纠正(就好像它不在并发环境)如果发现过早的负载值不正确;在这种情况下,装载最终会成功.换句话说,另一个线程的存在如何使加载线程不“意识到”加载线程中的无序加载是无效的？

我希望我设法传达问题,因为我真的看到它.

片段：

Because all of the processors mentioned above,in addition to the .NET memory model,allow load-to-load reordering in some circumstances,the load of m_value could move after the load of the object’s fields. The effect would be similar and marking m_value as volatile prevents it. Marking the object’s fields as volatile is not necessary because the read of the value is an acquire fence and prevents the subsequent loads from moving before,no matter whether they are volatile or not. This might seem ridiculous to some: how could a field be read before a reference to the object itself? This appears to violate data dependence,but it doesn’t: some newer processors (like IA64) employ value speculation and will execute loads ahead of time. If the processor happens to guess the correct value of the reference and field as it was before the reference was written,the speculative read could retire and create a problem. This kind of reordering is quite rare and may never happen in practice,but nevertheless it is a problem.

代码示例：

public class LazyInitOnlyOnceRef<T> where T : class
{
    private volatile T m_value;
    private object m_sync = new object();
    private Func<T> m_factory;

    public LazyInitOnlyOnceRef(Func<T> factory) { m_factory = factory; }

    public T Value
    {
        get
        {
            if (m_value == null)
            {
                lock (m_sync)
                {
                    if (m_value == null)
                        m_value = m_factory();
                }
            }
            return m_value;
        }
    }
}