Concurrency by Tutorials

Question 1

What is concurrency?

Answer 1

the decomposability property of a program, algorithm, or problem into order-independent units

Question 2

Why use concurrency?

Answer 2

Critical to ensure that your app runs smoothly as possible and that the end user is not ever forced to wait.

Question 3

What are 2 ways to use concurrency in iOS?

Answer 3

1. Grand Central Dispatch

2. Operation class

Question 4

What is the purpose of GCD?

Answer 4

Queue up tasks - method or closure - that can be run in parallel.

Question 5

What is a synchronous task?

Answer 5

Your app will wait and block the current run loop until execution finishes before moving to the next task

Question 6

What is an asynchronous task?

Answer 6

App will start the task but return execution to your app immediately

Question 7

What is a serial queue?

Answer 7

Only have a single thread associated with them and thus only a single task can be executed at a given time

Question 8

What is a concurrent queue?

Answer 8

Utilize as many threads as the system has resources for

Question 9

What are some advantages of splitting your app into multiple threads?

Answer 9

1. Faster execution
2. Responsiveness
3. Optimized resource consumption

Question 10

How do you create a serial dispatch queue in swift?

Answer 10

let queue = DispatchQueue(label: “”)

Question 11

Are dispatch queues concurrent or serial by default?

Answer 11

Serial

Question 12

How do you create a global QoS concurrent queue?

Answer 12

let queue = DispatchQueue.global(qos: .userInteractive)

Question 13

How do you create a concurrent dispatch queue in swift?

Answer 13

let queue = DispatchQueue(label: “”, attributes: .concurrent)

Question 14

List the 6 quality of services classes for global concurrent queues Apple offers? (highest to lowest priority)

Answer 14

1) .userInteractive
2) .userInitiatted
3) .utility
4) .background
5) .default
6) .unspecified

Question 15

How to create your own concurrent queue with utility QoS?

Answer 15

let queue = DispatchQueue(label: “”, qos; .utility, attributes: .concurrent)

Question 16

When should you use the .userInteractive QoS?

Answer 16

Tasks that the user directly interacts with. UI-updating calculations, animations, etc.

Question 17

When should you use the .userInitiated QoS?

Answer 17

When the user kicks off a task from the UI that needs to happen immediately but can be done async. (If a user clicked a button, this is probably the queue you want)

Question 18

When should you use the .utility QoS?

Answer 18

Tasks that would typically include a progress indicator. Long-running computations, I/0, networking, data feeds

Question 19

When should you use the .background QoS?

Answer 19

Tasks that the user is not directly aware of. No user interaction, not time-sensitive. Prefetching, DB maintenance, backups

Question 20

When should you use the .default QoS?

Answer 20

This default value of qos argument. Falls between .userInitiated and .utility

Question 21

When to use the .unspecified QoS?

Answer 21

Exists to support legacy APIs that may opt-out of a QoS

Question 22

What is a DispatchWorkItem?

Answer 22

A class that provides an actual object to hold the code you wish to submit to a queue

Question 23

How do you create and execute DispatchWorkItem?

Answer 23

let workItem = DispatchWorkItem {
   print("run code")
}
queue.async(execute: workItem)

Question 24

When would you use a DispatchWorkItem instead of just using anonymous closure?

Answer 24

If you have need to cancel the task before or during execution

Question 25

How do you identify another DispatchWorkItem that should be executed after the current work item completes?

Answer 25

DispatchWorkItem's notify(queue:execute:) method

Question 26

What is DispatchGroup class used for?

Answer 26

When you want to track the completion of a group of tasks

Question 27

Give an example of using a group in code that updates a text label after the group is completed

Answer 27

``` let group = DispatchGroup() queue.async(group: group) { ... } group.notify(queue: DispatchQueue.main) { self?.textLabel.text = "Job Done!" } ```

Question 28

True or False: All jobs submitted to a group must be on the same queue?

Answer 28

False: jobs can be submitted on multiple queues

Question 29

How can you synchronously wait on a group to finish?

Answer 29

``` let group = DispatchGroup() group.wait(timeout:) ```

Question 30

What is DispatchGroup's group.enter() method used for?

Answer 30

Lets the dispatch group know that there's another block of code running, which should be counted towards group overall completion

Question 31

What is DispatchGroup's group.leave() method used for?

Answer 31

Lets the group know that corresponding group.enter() has finished

Question 32

Example of queue and group that use enter() and leave()

Answer 32

queue.async(group: group) { group.enter() someAsyncMethod { defer { group.leave() } } }

Question 33

What is DispatchSemaphore used for?

Answer 33

Specify how many concurrent accesses to the resource are allowed

Question 34

How do you request permission for resource with DispatchSemaphore?

Answer 34

semaphore.wait()

Question 35

How do you notify that resource count should be decremented?

Answer 35

semaphore.signal()