Threads, Queues, and More: Async Programming in iOS

THREADS, QUEUES,
AND MORE: ASYNC
PROGRAMMING
IN IOS
Why Async?

Long running is:
>= 0.01666 seconds

Perform long running tasks
asynchronously
Threads vs Queues

Main Queue
Main Queue
UI
{
code…
}
UI UI
{
code…
}
{
…
}
Main Queue manages the main thread

Main Queue
UI
{
code…
}
UI UI
{
code…
}
{
…
}
User Interface / UIKit all happens on the main queue
Main Queue
UI
{
code…
}
UI UI
{
code…
}
{
…
}
Any custom code in view controllers (for example, viewDidLoad)
executes on main queue

Main Queue
How do we get off
the main queue?

NSObject / NSThread
Grand Central Dispatch
NSOperation
Networking
NSObject / NSThread

NSObject methods
- performSelector:withObject:afterDelay:
- performSelector:withObject:afterDelay:inModes:
- performSelectorOnMainThread:withObject:waitUntilDone:
- performSelectorOnMainThread:withObject:waitUntilDone:modes:
- performSelector:onThread:withObject:waitUntilDone:
- performSelector:onThread:withObject:waitUntilDone:modes:
- performSelectorInBackground:withObject:
…this approach uses threads,
not queues.
NOT recommended.

• Dispatch Queues
• Global
• Concurrent
• Serial
• Dispatch Groups

Dispatch Queues
First, get a reference
to the queue

Dispatch Async - Swift 3
let queue = DispatchQueue.global(qos: .background)
for iteration in 1...iterations {
queue.async { [weak self] in
self?.longRunningTask(with: iteration)
}
}
Dispatch Queue Types - Swift 3
let queue:DispatchQueue
switch approach {
case .dispatchConcurrent:
queue = DispatchQueue.global(qos: .default)
case .dispatchSerial:
queue = DispatchQueue(label: "SerialQueue")
default:
queue = DispatchQueue(label: "ConcurrentQueue",
qos: .background,
attributes: .concurrent,
autoreleaseFrequency: .inherit,
target: nil)
}

Add work
to the queue
let queue = DispatchQueue.global(qos: .background)
}
}

Dispatch Work Item - Swift 3
let workItem = DispatchWorkItem(qos: .default,
flags: .assignCurrentContext) {
…
}
queue.async(execute: workItem)
Go back to the main queue
to update UI

…
DispatchQueue.main.async {
strongSelf.taskDelegate?.longRunningTaskDidComplete(with: results)
}
How does it look?

Group tasks
First, create a group

Dispatch Group - Swift 3
func performLongRunningTask(with iterations:Int) {
let queue:DispatchQueue = DispatchQueue.global(qos: .default)
let workGroup = DispatchGroup()
print("In iteration (iteration)")
workGroup.enter()
workGroup.leave()
}
}
workGroup.notify(queue: queue) {
self.taskDelegate?.longRunningTaskDidComplete(with: self.results)
print("Called delegate for group")
}
}
}
Enter the group

workGroup.enter()
workGroup.leave()
}
}
}
}
}
Do your work

func longRunningTask(with iteration:Int) {
var iterationResults:[String] = []
for counter in 1...10 {
Thread.sleep(forTimeInterval: 0.1)
iterationResults.append("Iteration (iteration) - Item (counter)")
}
if self.approach == .dispatchGroup {
self.results.append(contentsOf: iterationResults)
} else {
self.resultsQueue.sync {
}
}
}
Leave the group

workGroup.enter()
workGroup.leave()
}
}
}
}
}
Notify - group is “done”

workGroup.enter()
workGroup.leave()
}
}
}
}
}
How does it look?

Arrays are *not*
thread safe
Try with sync approach

func longRunningTask(with iteration:Int) {
var iterationResults:[String] = []
for counter in 1...10 {
Thread.sleep(forTimeInterval: 0.1)
iterationResults.append("Iteration (iteration) - Item (counter)")
}
if self.approach == .dispatchGroup {
} else {
self.resultsQueue.sync {
}
}
}
Better?

Create an OperationQueue
OperationQueue - Swift 3
var taskOperationQueue:OperationQueue = OperationQueue()
// for a serial queue, do this:
taskOperationQueue.maxConcurrentOperationCount = 1

Add an Operation
to the Queue
taskOperationQueue.addOperation({ [weak self] in
})
}

var operationsToAdd:[Operation] = []
var previousOperation:Operation?
let newOperation = CustomOperation(iteration: iteration,
delegate: taskDelegate)
if let actualPreviousOperation = previousOperation {
newOperation.addDependency(actualPreviousOperation)
}
operationsToAdd.append(newOperation)
previousOperation = newOperation
}
taskOperationQueue.addOperations(operationsToAdd, waitUntilFinished: false)
Go back to the main queue
to update UI

OperationQueue.main.addOperation {
strongSelf.taskDelegate?.longRunningTaskDidComplete(with: results)
}
In action…

OperationQueue
• InvocationOperation, BlockOperation, or Operation subclass
• OperationQueues and Operations support cancellation
• OperationQueues and Operations support dependencies, even across queues
• Can suspend and resume a queue; clear all operations out of a queue
Networking

Use URLSession &
URLSessionTasks
Networking - Swift 3
let config = URLSessionConfiguration.default
config.timeoutIntervalForRequest = 5
config.httpAdditionalHeaders =
["X-Token":"F06427CB-00AE-422C-992F-854689B5419E"]
self.urlSession = URLSession(configuration: config)

var iterationComponents:URLComponents = URLComponents()
iterationComponents.scheme = "http"
iterationComponents.host = "joes-macbook-air.local"
iterationComponents.port = 8080
iterationComponents.path = "/iteration(iteration).json"
guard let iterationURL = iterationComponents.url else {
return nil
}
let request = URLRequest(url: iterationURL)
let task = urlSession?.dataTask(with: request, completionHandler:
{ (data, response, error) in
…
}
NOTE: “error” means cannot
connect to host
Response may also be an error.
Check response status code too.

if let actualError = error {
print("Error encountered with data task: (actualError.localizedDescription)")
return
}
guard let actualResponse = response as? HTTPURLResponse,
actualResponse.statusCode == 200 else {
print("Unexpected response received")
return
}
Completion handler is on
background queue -
do your “heavy lifting” there

guard let actualData = data else {
print("No data received...")
return
}
let json = try? JSONSerialization.jsonObject(with: actualData,
options: [])
guard let info = json as? [String:Any],
let results = info["iterations"] as? [String] else {
print("Data received was not in the expected format")
return
}
Dispatch to main queue to
update UI with results

self.taskDelegate?.longRunningTaskDidComplete(with: results)
}
Things to Avoid

General Async Risks
Simultaneous Updates

Race Conditions /
Out of Sequence Updates
Deadlocks

Thread Explosion
Updating UI from
background thread

Unexpected queue from
block-based SDK method

Unexpected Queue
In iOS SDK, watch out for:
• Completion Handlers
• Error Handlers
• any method parameter titled “withBlock:”
Over-dispatching

Over-dispatching
dispatch_queue_t workQueue =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
dispatch_async(workQueue, ^{
[[self managedObjectContext] performBlock:^{
[testObject setValue:@"test" forKey:@"testKey"];
}];
});
Retain Cycles

Retain Cycles
• Happens when the caller retains the block or closure, and the block or closure retains the
caller.
• Different semantics for preventing in Objective-C, Swift 3.0
• Gist is: Avoid a strong reference to the caller from the block / closure unless absolutely
necessary, and make sure the reference gets released
Learn more?
MARTIANCRAFT TRAINING…

@jwkeeley
THANK YOU
martiancraft.com

Threads, Queues, and More: Async Programming in iOS

More Related Content

What's hot

Similar to Threads, Queues, and More: Async Programming in iOS

More from TechWell

Recently uploaded

Threads, Queues, and More: Async Programming in iOS