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()將只調用一次，用於運行兩個（或多個）線程的每一個可能的組合。