C# 延迟初始化 && 竞速初始化？

Question

readingLazyInitializer 之后是：

它提供了另一种具有多个线程的初始化模式 竞相初始化。

这是一个示例：

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

问题 #1

看：

为什么#A 说它实现了双重检查锁定？它只是一个获得财产？

问题 #2

#B（lambda 表达式）是线程安全的吗？

问题 #3

所以我通过查看样本搜索了这个“race-to-initialize”：

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（lambda 表达式）是线程安全的吗？

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() 将只被调用一次，对于两个（或更多）正在运行的线程的每个可能的组合。