Swift: Safe Thread using NSLock or Concurrent Queue [closed] - ios

Question

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 2 years ago.
Improve this question
What is the best way to do Safe Thread?
Using 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)
}
}
}
}
Using 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)
}
}
}
}
Or serial 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 or a Queue with .concurrent attribute for the above case, and why?

Answer 1

Concurrent queue with barrier flag is more efficient than using NSLock in this case.
Both of them block other operations while a setter is running but the difference is when you call multiple getters concurrently or parallelism.
NSLock: Only allow 1 getter running at a time
Concurrent Queue with barrier flag: Allow multiple getters running at a time.