在阅读有关 LazyInitializer ，它是：

它提供的初始化的另一种方式，有多个线程   比赛进行初始化。

It offers another mode of initialization that has multiple threads race to initialize.

下面是一个例子：

Expensive _expensive;
public Expensive Expensive
     {
       get // Implement double-checked locking
         {
           LazyInitializer.EnsureInitialized (ref _expensive,() => new Expensive());
           return _expensive;
         }
     }

问题1

看：

looking at :

为什么＃A说，它的器具双重检查锁定？它只是一个get proeprty？

why #A says its implements double-checking locking ? it is just a get proeprty ?

问题＃2

请问＃B（拉姆达EX pression）是线程安全的？

Does #B (lambda expression) is thread safe ?

问题3

所以，我通过看一个示例搜索关于此的比赛到初始化的事情：

So i searched about this "race-to-initialize" thing by looking at a sample:

volatile Expensive _expensive;
public Expensive Expensive
{
  get
  {
    if (_expensive == null)
    {
      var instance = new Expensive();
      Interlocked.CompareExchange (ref _expensive, instance, null);
    }
    return _expensive;
  }
}

然后我想到了：心不是比赛进行到初始化是线程安全的。

and then i thought about : isnt race to initialize is thread safe ?

E /克/如果2个线程进入：

e/g/ if 2 threads get into :

昂贵的对象将被创建两次！

the expensive object will be created twice !

所以，再一次，3个问题

So again , 3 question

1）为什么＃A说，它的器具双重检查锁定？它只是一个get proeprty？

1)why #A says its implements double-checking locking ? it is just a get proeprty ?

2）是否＃B（拉姆达EX pression）是线程安全的？

2)Does #B (lambda expression) is thread safe ?

3）心不是种族初始化是线程安全的。

3)isnt race to initialize is thread safe

推荐答案

有 EnsureInitialized 的各种重载。一些接受的SyncLock 对象（可以是空，并将由 EnsureInitialized 法）。人无我有一个的SyncLock 作为参数。所有 EnsureInitialized 的保证，如果被称为在同一时间两个（或更多），而对象是未初始化的不同的线程，这两个线程将收到回一个引用同一个对象。所以：

Expensive _expensive;

// On thread 1
LazyInitializer.EnsureInitialized (ref _expensive,() => new Expensive());

// On thread 2
LazyInitializer.EnsureInitialized (ref _expensive,() => new Expensive());

Expensive _expensive;
object _sync = null;
bool _useless;

// On thread 1
LazyInitializer.EnsureInitialized (ref _expensive, ref useless, ref _sync, () => new Expensive());

// On thread 2
LazyInitializer.EnsureInitialized (ref _expensive, ref useless, ref _sync, () => new Expensive());