双重检查锁优化,以在Swift中实现线程安全的延迟加载

万一你想知道,这是我目前正在努力的DI library.

我正在谈论的代码是the following：

final class Builder<I> {

   private let body: () -> I

   private var instance: I?
   private let instanceLocker = NSLock()

   private var isSet = false
   private let isSetDispatchQueue = DispatchQueue(label: "(Builder.self)",attributes: .concurrent)

   init(body: @escaping () -> I) {
       self.body = body
   }

   private var syncIsSet: Bool {
       set {
          isSetDispatchQueue.async(flags: .barrier) {
             self.isSet = newValue
          }
       }
       get {
          var isSet = false
          isSetDispatchQueue.sync {
              isSet = self.isSet
          }
          return isSet
       }
   }

   var value: I {

       if syncIsSet {
           return instance! // should never fail
       }

       instanceLocker.lock()

       if syncIsSet {
           instanceLocker.unlock()
           return instance! // should never fail
       }

       let instance = body()
       self.instance = instance

       syncIsSet = true
       instanceLocker.unlock()

       return instance
    }
}

逻辑是允许并发读取isSet,因此对实例的访问可以从不同的线程并行运行.为了避免竞争条件(这是我不能100％肯定的部分),我有两个障碍.设置为Set时设置一个,设置实例时设置一个.诀窍是仅在isSet设置为true后解锁后者,因此等待onLocker解锁的线程在isSet上被异步写入并发调度队列时第二次被锁定.

我认为我离这里的最终解决方案非常接近,但由于我不是分布式系统专家,所以我想确定一下.

此外,使用调度队列不是我的第一选择,因为它让我觉得阅读isSet不是超级高效,但同样,我不是专家.

所以我的两个问题是：

>这是100％线程安全的,如果没有,为什么？
>有效率吗？
在Swift中这样做的方式？