Synchronizing between different threads in Swift - swift

Question

Could anyone provide advice on how to lock between threads in Swift? Specifically, I have code that separates the model from the view. The model processes adds, updates, and deletes separately before committing for the view to access. I have code that runs on the background thread to keep the main thread nice and snappy. The sample code below is similar to what I’ve implemented and it works. However, I worry that it’s overly complicated with the DispatchQueue and locks. I don’t know of a better way to lock between threads and this seems to work but I’m sure someone smarter than I can show a more elegant solution? Any advice is greatly appreciated.
class MyClass {
private let model = MyDataModel()
private let syncQueue = DispatchQueue(label: "MyClass")
private let lock = NSLock()
/**
This function can be called from several different places on several different threads.
*/
func processAdds() {
assert(!Thread.isMainThread)
// Ensure no other thread sneaks in and modifies the model while we're working.
syncQueue.sync {
self.lock.lock() // Is this overkill?
// Modify the model.
self.model.calculatePendingAdds()
// Commit the model.
self.model.commit()
// Do some long running stuff with the committed data.
self.model.doStuff()
DispatchQueue.main.async {
self.updateTheUI() // Must be done on the main thread but we don't want another background thread sneaking in and modifying the model.
// Only release the lock when this main thread async block is finished.
self.lock.unlock() // I think this is not overkill because I can't exit the syncQueue before the main thread is finished updating the UI.
}
}
/**
This function can be called from several different places on several different threads.
*/
func processDeletes() {
assert(!Thread.isMainThread)
// Ensure no other thread sneaks in and modifies the model while we're working.
syncQueue.sync {
self.lock.lock() // Is this overkill?
// Modify the model.
self.model.calculatePendingDeletes()
// Commit the model.
self.model.commit()
// Do some long running stuff with the committed data.
self.model.doStuff()
DispatchQueue.main.async {
self.updateTheUI() // Must be done on the main thread but we don't want another background thread sneaking in and modifying the model.
// Only release the lock when this main thread async block is finished.
self.lock.unlock() // I think this is not overkill because I can't exit the syncQueue before the main thread is finished updating the UI.
}
}
}

Answer 1

After digging around and trying some experimenting I realized using a custom dispatch queue with a lock was indeed overkill. The dispatch queue acts like a lock already so using it with a lock was redundant. I really just needed a lock that could be unlocked on a different thread so I figured a mutex was better. I got rid of the custom queue and lock and replaced it with this:
class MyClass {
private let model = MyDataModel()
private let mutex = pthread_mutex_t()
/**
This function can be called from several different places on several different threads.
*/
func processAdds() {
assert(!Thread.isMainThread)
// Ensure no other thread sneaks in and modifies the model while we're working.
pthread_mutex_lock(&self.mutex)
// Modify the model.
self.model.calculatePendingAdds()
// Commit the model.
self.model.commit()
// Do some long running stuff with the committed data.
self.model.doStuff()
DispatchQueue.main.async {
self.updateTheUI() // Must be done on the main thread but we don't want another background thread sneaking in and modifying the model.
// Only release the lock when this main thread async block is finished.
pthread_mutex_unlock(&self.mutex)
}
}
/**
This function can be called from several different places on several different threads.
*/
func processDeletes() {
assert(!Thread.isMainThread)
// Ensure no other thread sneaks in and modifies the model while we're working.
pthread_mutex_lock(&self.mutex)
// Modify the model.
self.model.calculatePendingDeletes()
// Commit the model.
self.model.commit()
// Do some long running stuff with the committed data.
self.model.doStuff()
DispatchQueue.main.async {
self.updateTheUI() // Must be done on the main thread but we don't want another background thread sneaking in and modifying the model.
// Only release the lock when this main thread async block is finished.
pthread_mutex_unlock(&self.mutex)
}
}
}
Seems simple and works.