C＃懒惰初始化&&比赛初始化？

Question

reading经过约LazyInitializer，它是：

它提供了具有多线程 比赛初始化初始化的另一种方式。

这里是一个示例：

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

问题＃1

看：

为什么#A说，它的工具双重检查锁定？它只是一个获得成功？

问题2

不会＃B（lambda表达式）是线程安全的？

问题＃3

于是我去搜索这个通过看样品“比赛到初始化”件事：

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

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

E/G/2个，如果线程进入：

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

如此反复，3问题

1）为什么说＃A的工具双重检查锁定？它只是一个获得成功？

2）#B（l​​ambda表达式）是线程安全的吗？

3）心不是比赛来初始化是线程安全的

Answer 1

还有的EnsureInitialized各种重载。有些接受synclock对象（可以是null并将由EnsureInitialized方法创建）。其他人没有synclock作为参数。所有的EnsureInitialized保证，如果在未初始化对象的同时由两个（或更多）不同的线程调用，则两个线程将接收对同一对象的引用。所以：

Expensive _expensive; 

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

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

这个_expensive会被两个线程看到的对象是一样的。

唯一的问题是new Expensive()可能会被调用两次（每个线程一次，所以在多线程竞争中它可能会被调用更多次。）

如果你不想要它，使用synclock过载：

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()); 

现在new Expensive()将只调用一次，用于运行两个（或多个）线程的每一个可能的组合。