Pfthb

I've been reading a lot of example code, i know that generally you want the code that updates your UI to execute on the main thread. And xcode will complain, at runtime, if i m missing something. Only sometimes though.

So how is code that updates your UI actually defined?
Is presenting an alert updating the UI? calling reloadData() on a UITableView? What about simply setting the text of a UILabel?
Especially with these three, i've been seeing and using it both ways in my app and can't really figure out a rule. Especially since xcode lets me get away with both... sometimes.

Edit: Ohh, i understand where my confusion came from. I thought it was random what thread you were on. But you are actually "always" on the main thread, unless you do something like a task, which runs on a background thread.

So the Main Thread Checker didn't actually let me "get away" with using reload() and changing labels in my viewController falsely. It's just that i was guaranteed to be on the main thread.

I thought i had to suddenly wrap every single label change everywhere in dispatch.async.

Xcode letting you do something does not mean you should do that thing.

Reloading a table view, showing an alert, and changing a label's text are all UI updates. They all change what you see on screen, so they are UI updates. Always do these on the main thread.

Things that are not UI changes: sending HTTP requests, crunching numbers, loading data from some database. They don't change what you see on screen.

You must update your UI on main thread so that user can not feel some lag or disturbance during interacting with your UI. i.e. reload table, change text, change color, etc.

And you can perform your time taking operations on background thread so that your app performs well during the operations. i.e. HTTP requests, Database operations, long running loops, large nested conditions etc.

You can write your code like this....

// define these methods in your helper class or wherever you want.
public func BACKGROUND_QUEUE(_ codeBlock:@escaping (() -> Void)) -> Void 
 return DispatchQueue.global(qos: DispatchQoS.QoSClass.background).async(execute: codeBlock)


public func MAIN_QUEUE(_ codeBlock:@escaping (() -> Void)) -> Void 
 return DispatchQueue.main.async(execute: codeBlock)

and use like this.

func fetchData() 

 BACKGROUND_QUEUE 
 //your http request to get some text
 let text = yourResult
 MAIN_QUEUE 
 textLabel.text = text
 
 

The rule “update the UI only on the main thread” covers only part of the truth, better stick to what the UIKit documentation states:

Important

Use UIKit classes only from your app’s main thread or main
dispatch queue, unless otherwise indicated. This restriction
particularly applies to classes derived from UIResponder or that
involve manipulating your app’s user interface in any way.

This restriction applies not only to (visible) updates of what is presented to the user, but to any UIKit classes, unless otherwise specified.

As an example, accessing the applications delegate does not affect the
UI, but doing so on a non-main thread causes a “Main Thread Checker violation”:

DispatchQueue.global().async 
 let shared = UIApplication.shared.delegate


// Main Thread Checker: UI API called on a background thread: -[UIApplication delegate]