C#懒惰和竞赛初始化？

By default,Lazy objects are thread-safe. That is,if the constructor
does not specify the kind of thread safety,the Lazy objects it
creates are thread-safe. In multi-threaded scenarios,the first thread
to access the Value property of a thread-safe Lazy object initializes
it for all subsequent accesses on all threads,and all threads share
the same data. Therefore,it does not matter which thread initializes
the object,and race conditions are benign.

如果您实际上询问它是如何在内部工作的,那么它似乎正在使用某种锁：

object obj = Volatile.Read<object>(ref this.m_threadSafeObj);
        bool flag = false;
        try
        {
            if (obj != Lazy<T>.ALREADY_INVOKED_SENTINEL)
            {
                Monitor.Enter(obj,ref flag);
            }
            if (this.m_boxed == null)
            {
                boxed = this.CreateValue();
                this.m_boxed = boxed;
                Volatile.Write<object>(ref this.m_threadSafeObj,Lazy<T>.ALREADY_INVOKED_SENTINEL);
            }
            else
            {
                boxed = (this.m_boxed as Lazy<T>.Boxed);
                if (boxed == null)
                {
                    Lazy<T>.LazyInternalExceptionHolder lazyInternalExceptionHolder = this.m_boxed as Lazy<T>.LazyInternalExceptionHolder;
                    lazyInternalExceptionHolder.m_edi.Throw();
                }
            }
        }
        finally
        {
            if (flag)
            {
                Monitor.Exit(obj);
            }
        }

注意Monitor.Enter和Monitor.Exit调用.