线程安全的

Question

我在斯威夫特3中创建一个简单单的单身getter和setter：

class MySingleton { 
    private var myName: String 
    private init() {} 
    static let shared = MySingleton() 

    func setName(_ name: String) { 
     myName = name 
    } 

    func getName() -> String { 
     return myName 
    } 
} 

因为我做了init()私有的，也宣告shared实例是static let，我想初始化是线程安全的。但是myName的getter和setter函数又是如何线程安全的？

Answer 1

你说得对，你写的那些getter不是线程安全的。在Swift中，目前最简单（最安全）的方法是使用Grand Central Dispatch队列作为锁定机制。最简单（也是最容易推理的）方法是使用基本的串行队列。

class MySingleton { 

    static let shared = MySingleton() 

    // Serial dispatch queue 
    private let lockQueue = DispatchQueue(label: "MySingleton.lockQueue") 

    private var _myName: String 
    var myName: String { 
     get { 
      var result: String! 

      lockQueue.sync { 
       result = self._myName 
      } 

      return result 
     } 

     set { 
      lockQueue.sync { 
       self._myName = newValue 
      } 
     } 
    } 

    private init() { 
     _myName = "initial name" 
    } 
} 

使用串行调度队列将保证先进先出执行以及实现对数据的“锁定”。也就是说，数据在更改时无法读取。在这种方法中，我们使用sync来执行数据的实际读取和写入，这意味着调用者将总是被迫等待其轮到，类似于其他锁定基元。

注意：这不是most performant的方法，但它很容易阅读和理解。这是一个很好的通用目的解决方案，以避免竞争条件，但并不意味着为并行算法开发提供同步。

来源： https://mikeash.com/pyblog/friday-qa-2015-02-06-locks-thread-safety-and-swift.html What is the Swift equivalent to Objective-C's "@synchronized"?

Answer 2

稍微不同的方式来做到这一点（这是从一个Xcode 9游乐场）是使用并发队列，而不是一个串行队列。

final class MySingleton { 
    static let shared = MySingleton() 

    private let nameQueue = DispatchQueue(label: "name.accessor", qos: .default, attributes: .concurrent) 
    private var _name = "Initial name" 

    private init() {} 

    var name: String { 
     get { 
      var name = "" 
      nameQueue.sync { 
       name = _name 
      } 

      return name 
     } 
     set { 
      nameQueue.async(flags: .barrier) { 
       self._name = newValue 
      } 
     } 
    } 
} 

• 使用并发队列意味着多个读取来自多个线程未阻止彼此。由于在获取时没有突变，因此可以同时读取该值，因为...
• 我们正在使用.barrier异步分派来设置新值。该块可以异步执行，因为调用者不需要等待值的设置。该块将不会运行，直到其前面的并发队列中的所有其他块完成。所以，当这个setter等待运行时，现有的挂起读操作不会受到影响。障碍意味着当它开始运行时，不会有其他块运行。有效地，在setter的持续时间内将队列变成一个串行队列。在此模块完成之前不能进一步读取。当程序块完成后，新的值已经被设置，在这个setter之后添加的任何获得者现在可以同时运行。