Ans :
1. Thread : It is lightweight way to implement multiple paths of execution inside of an application.
2. Multi threading : iPhone CPU can only perform one operation at a time – once per clock cycle. Multi threading allows the processor to create concurrent threads it can switch between, so multiple tasks can be executed at the same time.
It appears as if the two threads are executed at the same time, because the processor switches rapidly between executing them. As a smartphone or desktop user, you don’t notice the switches because they occur so rapidly.
Multi threading allows a CPU to rapidly switch between multiple tasks in such a way that it appears as if the tasks are executed simultaneously.
You can’t update an app’s UI outside the main thread.
Race Condition : A race condition occurs when two tasks are executed concurrently, when they should be executed sequentially in order to be done correctly. You cant change view constraint while it is being calculated. So UI activity should be done in main thread so it is executed sequentially.
3. GCD : Grand Central Dispatch is a wrapper around creating threads and managing that code. Its emphasis is on dispatching.
low_level_C coding :
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
// Download file or perform expensive task
dispatch_async(dispatch_get_main_queue()) {
// Update the UI
}
}
Swift 3+ code :
DispatchQueue.global(qos: .userInitiated).async {
// Download file or perform expensive task
DispatchQueue.main.async {
// Update the UI
}
}
There are 4 qos - quality of service level (Priority) from higher to low :
.userInteractive,
.userInitiated,
.utility
.background.
For delaying task :
let delay = DispatchTime.now() + .seconds(60)
DispatchQueue.main.asyncAfter(deadline: delay) {
// Dodge this!
}
4. Operation Queue :
Operations in Swift are a powerful way to separate responsibilities over several classes while keeping track of progress and dependencies. They’re formally known as NSOperations and used in combination with the OperationQueue.
An Operation is typically responsible for a single synchronous task. It’s an abstract class and never used directly. You can make use of the system-defined BlockOperation subclass or by creating your own subclass. You can start an operation by adding it to an OperationQueue or by manually calling the start method. However, it’s highly recommended to give full responsibility to the OperationQueue to manage the state.
//Making use of the system-defined BlockOperation looks as follows:
let blockOperation = BlockOperation {
print("Executing!")
}
let queue = OperationQueue()
queue.addOperation(blockOperation)
//And can also be done by adding the block directly on the queue:
queue.addOperation {
print("Executing!")
}
//The given task gets added to the OperationQueue that will start the execution as soon as possible.
Different states of an operation
An operation can be in several states, depending on its current execution status.
- Ready: It’s prepared to start
- Executing: The task is currently running
- Finished: Once the process is completed
- Canceled: The task canceled
