線程安全的

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之後添加的任何獲得者現在可以同時運行。