In this iteration of iOS Meetup, The experts from Seven Peaks Software will walk you through on the Swift programming language, Giving you the latest tips and tricks for you to be success on the iOS development Rupendra opened up the meetup with Concurrency in Swift. Concurrency allows programs to deal with multiple tasks at once. But writing a concurrent program is not as easy as it seems. Dealing with threads and locks can be quite cumbersome, making concurrent programs difficult to write. His Topic will focus on making it straightforward and understandable so that anyone who is an intermediate to advanced Swift developer can apply these concepts to their projects.

1. SEVEN PEAKS SOFTWARE
MEETUP
Concurrency In Swift
23.02.2022
r4

2. Concurrency | kənˈkərənsē |
noun
the fact of two or more events or circumstances happening or existing at the same time: the
unfortunate concurrency of both high debt and high unemployment.
In computer science, concurrency is the ability of different parts or units of a program, algorithm, or
problem to be executed out-of-order or in partial order, without affecting the final outcome.
Concurrency
What?

3. Concurrency
Demo

4. ● Decomposability of a program
● Ability of parallel execution
● Order independent outcome
Concurrency
Prerequisite

5. ● Minimize Response Time
● Maximise Throughput
● Efficient Resource Utilisation
Concurrency
Why?

6. ● Thread
● Grand Central Dispatch (GCD)
● OperationQueue
● Async-Await (Swift 5.5)
Concurrency
Solutions

7. import Foundation
let aThread = Thread(block: {
for anIndex in 0...10_00_000 {
Swift.print(anIndex)
}
})
aThread.threadPriority = 0.8
aThread.start()
Thread
Introduction
import Foundation
class MyThread :Thread {
override func main() {
for anIndex in 0...10_00_000 {
Swift.print(anIndex)
}
}
}
let aThread = MyThread()
aThread.threadPriority = 0.8
aThread.start()

8. Thread
Demo

9. DispatchQueue.global(qos: .background).async {
// Do some work here
DispatchQueue.main.async {
// return to the main thread.
print("Work completed and back on the main thread!")
}
}
DispatchQueue(
label: "myQueue",
qos: .background,
attributes: .concurrent
).async {
// Do some work here
}
GCD
Introduction

10. ● Three types based on creation access
○ Main Queue
○ Global Queue
○ Custom Queue
● Two types based on execution
○ Serial Queue (e.g. main queue)
○ Concurrent Queue (e.g. global queues)
GCD
Queue Types

11. ● User Interactive: executed as quickly as possible
● User Initiated: high priority queue
● Default: default priority queue
● Utility: low priority queue, executed with a view to keeping power efficiency as high as
possible without sacrificing too much performance
● Background: lowest priority queue, tasks will be executed with power efficiency as its priority
GCD
Quality Of Service (QOS)

12. GCD
Demo

13. class MyOperation :Operation {
override func main() {
for anIndex in 0...10_00_000 {
Swift.print(anIndex)
}
}
}
let anOperation = MyOperation()
let aBlockOperation =
BlockOperation {
// Do some work here
}
Operation Queue
Introduction
let anOperationQueue = OperationQueue()
anOperationQueue.addOperation(anOperation)

14. ● Ready: Itʼs prepared to start
● Executing: The task is currently running
● Finished: Once the process is completed
● Canceled: The task canceled
Operation Queue
States

15. let aCompressOperation = BlockOperation {
// Compress the image
}
let anUploadOperation = BlockOperation {
// Upload the image
}
anUploadOperation.addDependency(aCompressOperation)
let anOperationQueue = OperationQueue()
anOperationQueue.addOperation(aCompressOperation)
anOperationQueue.addOperation(anUploadOperation)
anOperationQueue.waitUntilAllOperationsAreFinished()
Operation Queue
Dependencies

16. let anOperation = MyOperation()
let anOperationQueue = OperationQueue()
anOperationQueue.addOperation(anOperation)
class MyOperation :Operation {
override func main() {
for anIndex in 0...10_00_000 {
if self.isCancelled {
break
} else {
Swift.print(anIndex)
}
}
}
}
Operation Queue
Canceling
anOperation.cancel()
anOperationQueue.cancelAllOperations()

17. Operation Queue
Demo

18. func getUsers() async throws -> Data {
let aUrl = URL(string: "https://api.example.com/users")!
let (aData, _) = try await URLSession.shared.data(from: aUrl)
return aData
}
Task {
let aUserArray = try await getUsers()
// Do anything with pUserArray
}
Async-Await
Introduction

19. ● Avoid callback hell / pyramid of doom
● Less number of lines of code
● Improved readability
● Guaranteed return result
Async-Await
Advantages

20. Async-Await
Demo