Swift:使用NSLock或并发队列的安全线程

Question

执行Safe Thread的最佳方法是什么？

使用NSLock:

class Observable<T> {
typealias Observer = (_ observable: Observable<T>, T) -> Void

private var observers: [Observer]
private let lock = NSLock()
private var _value: T
var value: T {
get {
lock.lock()
let value = _value
lock.unlock()
return value
}
set {
lock.lock()
_value = newValue
lock.unlock()
}
}

init(_ value: T) {
self._value = value
observers = []
}
func observe(observer: @escaping Observer) {
self.observers.append((observer))
}
private func notifyObservers(_ value: T) {
DispatchQueue.main.async {
self.observers.forEach { [unowned self](observer) in
observer(self, value)
}
}
}
}

使用Queue:

class SecondObservable<T> {
typealias Observer = (_ observable: SecondObservable<T>, T) -> Void

private var observers: [Observer]
private let safeQueue = DispatchQueue(label: "com.observable.value", attributes: .concurrent)
private var _value: T
var value: T {
get {
var value: T!
safeQueue.sync { value = _value }
return value
}
set {
safeQueue.async(flags: .barrier) { self._value = newValue }
}
}

init(_ value: T) {
self._value = value
observers = []
}
func observe(observer: @escaping Observer) {
self.observers.append((observer))
}
private func notifyObservers(_ value: T) {
DispatchQueue.main.async {
self.observers.forEach { [unowned self](observer) in
observer(self, value)
}
}
}
}

或串行Queue:

class ThirdObservable<T> {
typealias Observer = (_ observable: ThirdObservable<T>, T) -> Void

private var observers: [Observer]
private let safeQueue = DispatchQueue(label: "com.observable.value")
private var _value: T
var value: T {
get {
var value: T!
safeQueue.async { value = self._value }
return value
}
set {
safeQueue.async { self._value = newValue }
}
}

init(_ value: T) {
self._value = value
observers = []
}
func observe(observer: @escaping Observer) {
self.observers.append((observer))
}
private func notifyObservers(_ value: T) {
DispatchQueue.main.async {
self.observers.forEach { [unowned self](observer) in
observer(self, value)
}
}
}
}

对于上述情况，NSLock或具有.concurrent属性的Queue，为什么？

Answer 1

在这种情况下，带有barrier标志的并发队列比使用NSLock更高效。

当setter运行时，它们都会阻止其他操作，但不同的是，当您同时或并行调用多个getter时。

• NSLock:一次只允许运行1个getter
• 带有barrier标志的并发队列：允许一次运行多个getter