Updating Data vs Updating UI Dilemma - ios

Question

I have recently developed an iOS application with Swift which handles lots of background HTTP tasks and updates not only UI, but also static data for current session (lots of arrays, variables, etc) according to response data. I may be counted as new at iOS Developing and there are some points in which I am confused:
Updating UI from a background task is handled via GCD API. I have always handled these updates using:
dispatch_async(dispatch_get_main_queue, {
// Update UI
})
Let me give a scenario and clarify my point:
I have a view controller with a UITableView subview. This table view will display the list of something (lets say user names). I prepared and resumed an NSURLSessionDataTask:
let request = NSMutableURLRequest(URL: someURL)
let task = NSURLSession.sharedSession().dataTaskWithRequest(request) {
data, response, error in
// Handle error case
// Parse data, and receive a user list
// AppData.userList = parsed list
// Update table view
}
Some of my testers have faced some crashes related with dispatch calls and run loop in which I could not find the reason behind. I think this is related with my dispatch calls. Now I am reconsidering my design for this and here are my questions:
What is the difference of updating static data (array, dictionary, etc.) inside and outside of a dispatch_async call on main queue in completion handler of a http task (UI will be updated inside a dispatch call anyway, after the updates on my data)?. How can I ensure thread safety for background threads while reading from, inserting into or removing from an array?
Does making a dispatch_async call inside a closure (for task completion handler) may cause any problem?
Any clear comment or guiding would be very helpful! Thanks a lot already now

Answer 1

I'll try to give an aswer even if I didn't have a clear view about the answer.
You must update your UI from the main thread because UIKit objects (there is some exception if you want to draw on offscreen bitmap context) are not thread safe.
Here is what apple say about it:
Note: For the most part, UIKit classes should be used only from an
application’s main thread. This is particularly true for classes
derived from UIResponder or that involve manipulating your
application’s user interface in any way.
All the rendering routine should run on the main thread, most probably due to GPU acceleration and events management.
In contrast Foundation objects (except for some mutable one are thread safe), so can manage/manipulate and use them on a different thread.
Thread safety means that you can easily share you objects between threads.
If you use Foundation object on a background thread there is no problem at all, if you are using mutable once just inside that thread everything should work, the problem with mutable objects arise when you want to add objects to an array (for instance) from more threads.
If you provide your own classes you should provide thread safety by yourself.

Answer 2

First things first:
let request = NSMutableURLRequest(URL: someURL)
let task = NSURLSession.sharedSession().dataTaskWithRequest(request) { [weak self]
(data, response, error) in
if let weakself = self {
// ...
dispatch_async(dispatch_get_main_queue()) {
// update UI
}
}
}
Whenever you're making asynchronous calls, you need to make sure there are no self references to prevent any possible circular reference (memory leak).
What is the difference of updating static data (array, dictionary, etc.) inside and outside of a dispatch_async call on main queue in completion handler of a http task (UI will be updated inside a dispatch call anyway, after the updates on my data)?. How can I ensure thread safety for background threads while reading from, inserting into or removing from an array?
There is no difference between updating data inside and outside of a dispatch_async. You just need to make sure you're not mutating the array or dictionary while iterating through them. You can either do this by locking the data structure or creating a temporary shallow copy.
For example, if you're reading an Array that might be altered by another thread:
var integers = Array<Int>()
// The following creates an IMMUTABLE shallow copy of mutable array
let ints = integers
for value in ints {
// use value
}
// OR use locking
objc_sync_enter(integers)
for value in integers {
// use value
}
objc_sync_exit(integers)
// in another thread - lock before mutating
objc_sync_enter(integers)
integers.append(someIntValue)
objc_sync_exit(integers)
Of course, you can use other locking mechanisms. But the point is, you just need to make sure data is accessed in thread safe manner.
Does making a dispatch_async call inside a closure (for task completion handler) may cause any problem?
The answer is NO. As long as you make sure no reference to self exists within those closures and data accessible by competing threads are accessed/altered in a thread safe manner.