### What is output of following code?

Ans:

1.

var a = 6;
var b = 9;
let newClouser: ()->() = {[a,b] in
print(a+b)
}

a=3
b=3
newClouser()

Ans : 15
Explanation : We can't change value of a and b for closure. Reassignment will create new reference. We have captured value of a and b as we have used capture list ( [a,b] ). Capture list takes value of a and b as point of time.

If we have not used capture list ( [] ) then changing value for a and b affecting though value changing after closure declaration.

2.

print("1")
DispatchQueue.main.async {
print("2")
DispatchQueue.main.async {
print(3)
}
print("4")
}
print("5")

Ans :
1
5
2
4
5

Explanation :

You will always get 1, 2, 4, 3. The 5 will always be after the 1. But where it ends up in relation to the others depends on what queue the whole thing started on.

If this is started from the main queue then 5 will always be between 1 and 2.

Here's why:  This code starts on the main queue. 1 is printed. You then enqueue another block to run asynchronously on the main queue so that block will be run after the current block completes and the main queue gets to the end of the current run loop. The code continues to the next line which is to print 5. The current block ends and the next block on the main queue is run. This is the block of the first call to DispatchQueue.main.async. As this block runs it prints 2 (so now we have 1 5 2). Another block is enqueued to the main queue just like the last one. The current block continues and prints 4 (so now we have 1 5 2 4). The block ends and the next block on the main queue is run. This is the final block we added. That block runs and it prints 3 giving the final output of 1 5 2 4 3.

3.

for i in 0...10 {
DispatchQueue.main.async {
DispatchQueue.main.async {
print("Print1",i)
}
print("print2",i)
}
}

Ans :

Print2 0
Print2 1
Print2 2
Print2 3
Print2 4
Print2 5
Print2 6
Print2 7
Print2 8
Print2 9
Print2 10
Print1 0
Print1 1
Print1 2
Print1 3
Print1 4
Print1 5
Print1 6
Print1 7
Print1 8
Print1 9
Print1 10

4.

for i in 0...10 {
DispatchQueue.main.async {
DispatchQueue.main.sync {
print("Print1",i)
}
print("Print2",i)
}
}

Ans :

Explanation : Dispatch.main is a serial queue which has single thread to execute all the operations. If we call "sync" on this queue it will block all other operations currently running on the thread and try to execute the code block inside sync whatever you have written. This results in "deadlock".

This is a deadlock. It crashes because GCD detects this particular form of deadlock and aborts the program.

5.

for i in 0...10 {
DispatchQueue.main.async {
DispatchQueue.global().sync {
print("Print1",i)
}
print("Print2",i)
}
}

Ans :

Print1 0
Print2 0
Print1 1
Print2 1
Print1 2
Print2 2
Print1 3
Print2 3
Print1 4
Print2 4
Print1 5
Print2 5
Print1 6
Print2 6
Print1 7
Print2 7
Print1 8
Print2 8
Print1 9
Print2 9
Print1 10
Print2 10

Explanation :

6.

for i in 0...10 {
DispatchQueue.main.async {
DispatchQueue.global().async {
print("Print1",i)
}
print("Print2",i)
}
}

Ans :

Print2 0
Print1 0
Print2 1
Print1 1
Print2 2
Print1 2
Print2 3
Print1 3
Print2 4
Print1 4
Print2 5
Print2 6
Print1 5
Print1 6
Print2 7
Print1 7
Print2 8
Print1 8
Print2 9
Print1 9
Print2 10
Print1 10

Explanation :

7.

for i in 0...10 {
DispatchQueue.global().async {
DispatchQueue.global().async {
print("Print1",i)
}
print("Print2",i)
}
}

Ans :

Order is not fixed. Print in any order.

Explanation :

8.

for i in 0...10 {
DispatchQueue.global().sync {
DispatchQueue.global().sync {
print("Print1",i)
}
print("Print2",i)
}
}

Ans :

Print1 0
Print2 0
Print1 1
Print2 1
Print1 2
Print2 2
Print1 3
Print2 3
Print1 4
Print2 4
Print1 5
Print2 5
Print1 6
Print2 6
Print1 7
Print2 7
Print1 8
Print2 8
Print1 9
Print2 9
Print1 10
Print2 10

Explanation :

9.

for i in 0...10 {
DispatchQueue.global().async {
DispatchQueue.main.async {
print("Print1",i)
}
print("Print2",i)
}
}

Ans :
Print2 5
Print2 4
Print2 8
Print2 7
Print2 10
Print2 3
Print2 6
Print2 2
Print2 1
Print2 0
Print2 9
Print1 3
Print1 4
Print1 0
Print1 5
Print1 6
Print1 2
Print1 1
Print1 7
Print1 8
Print1 9
Print1 10

First all print from Print2 in random order, after that, Print1 printed in random order.

10.

for i in 0...10 {
DispatchQueue.global().sync {
DispatchQueue.main.async {
print("Print1",i)
}
print("Print2",i)
}
}

Ans :

Print2 0
Print2 1
Print2 2
Print2 3
Print2 4
Print2 5
Print2 6
Print2 7
Print2 8
Print2 9
Print2 10
Print1 0
Print1 1
Print1 2
Print1 3
Print1 4
Print1 5
Print1 6
Print1 7
Print1 8
Print1 9
Print1 10

Explanation :

11.

for i in 0...10 {
print("Manan1")
DispatchQueue.main.async {
print("Manan2")
DispatchQueue.main.async {
print("Print1",i)
}
print("print2",i)
}
}

Ans :

Manan1
Manan1
Manan1
Manan1
Manan1
Manan1
Manan1
Manan1
Manan1
Manan1
Manan1
Manan2
print2 0
Manan2
print2 1
Manan2
print2 2
Manan2
print2 3
Manan2
print2 4
Manan2
print2 5
Manan2
print2 6
Manan2
print2 7
Manan2
print2 8
Manan2
print2 9
Manan2
print2 10
Print1 0
Print1 1
Print1 2
Print1 3
Print1 4
Print1 5
Print1 6
Print1 7
Print1 8
Print1 9
Print1 10

Explanation :

### What are different type of Queues in GCD?

Ans :

Queue :

A Queue is a linear structure that follows the First In First Out (FIFO) order. Here we are going to use two types of queue `Serial queue` and `Concurrent queue`.

Serial Queue :

 Serial Queue

In the serial queue, only one task runs at a time. Once the first task ends then only the second task will begin. All the task follow the same sequence they have to wait until running task finish.

Create our own serial queue using GCD:

let serialQueue = DispatchQueue(label: "mySerialQueue")
serialQueue.async {

}

let myArray = [img1, img2, img3, img4, img5, img6]

for i in 0 ..< myArray.count {
serialQueue.async {
do {
let data = try Data(contentsOf: URL(string: myArray[i])!)
if let image = UIImage(data: data) {
DispatchQueue.main.async {
self.imageSerial[i].image = image
}
}
} catch {
print("error is \(error.localizedDescription)")
}
}

}

Concurrent Queue :

 Concurrent Queue

In the Concurrent queue, multiple tasks can run at the same time. The start time of the task will be the order they are added, means Task 0 start first then Task 1 will start after that and so on. Tasks can finish in any order.

Global queue is example of Concurrent queue.

// Synchronous
DispatchQueue.global().sync {
}

// Asynchronous
DispatchQueue.global().async {
}

Let's create own concurrent queue using GCD:

let concurrentQueue = DispatchQueue(label: "myConcurrentQueue", qos: .default, attributes: .concurrent, autoreleaseFrequency: .inherit, target: nil)

concurrentQueue.async {
}

let myArray = [img1, img2, img3, img4, img5, img6]

for i in 0 ..< myArray.count {
concurrentQueue.async {
do {
let data = try Data(contentsOf: URL(string: myArray[i])!)
if let image = UIImage(data: data) {
DispatchQueue.main.async {
self.imageConcurrent[i].image = image
}
}
} catch {
print("error is \(error.localizedDescription)")
}
}
}

### What is QOS?

Ans :

QOS - Quality of Services

A quality-of-service (QoS) class categorizes work to be performed on a DispatchQueue. By specifying the quality of a task, you indicate its importance to your app. When scheduling tasks, the system prioritizes those that have higher service classes.

Because higher priority work is performed more quickly and with more resources than lower priority work, it typically requires more energy than lower priority work. Accurately specifying appropriate QoS classes for the work your app performs ensures that your app is responsive and energy efficient.

Levels of Priority
After an app kicks off and starts a runloop on the main thread, one can begin taking advantage of QoS. QoS breaks out priorities into four different groups. Each one corresponds to common tasks one might find themselves coding in their iOS endeavors.
• User Interactive: Work that happens on the main thread, such as animations or drawing operations.
• User Initiated: Work that the user kicks off and should yield immediate results. This work must be completed for the user to continue.
• Utility: Work that may take a bit and doesn’t need to finish right away. Analogous to progress bars and importing data.
• Background: This work isn’t visible to the user. Backups, syncs, indexing, etc.

There are five global queues having quality of service level ranging  from high performance to high energy efficiency.
1. DispatchQueue.global(qos: .userInteractive) - highest priority
2. DispatchQueue.global(qos: .userInitiated)
3. DispatchQueue.global() // default
4. DispatchQueue.global(qos: .utility)
5. DispatchQueue.global(qos: .background) - lowest priority
DispatchQueue.global(qos: .userInteractive).async {
}

### What is mutating in swift?

Ans :

If you have ever tried using the mutating keyword in your class methods in Swift, the compiler will definitely yell at you because you are doing something wrong.
In swift, classes are reference type whereas structures and enumerations are value typesThe properties of value types cannot be modified within its instance methods by default. In order to modify the properties of a value type, you have to use the mutating keyword in the instance method. With this keyword, your method can then have the ability to mutate the values of the properties and write it back to the original structure when the method implementation ends.
Below is a simple implementation of Stack in Swift that illustrates the use of mutating functions.

struct Stack {
var items = [Int]() // Empty items array

mutating func push(_ item: Int) {
items.append(item)
}

mutating func pop() -> Int? {
if !items.isEmpty {
return items.removeLast()
}
return nil
}
}

var stack = Stack()
stack.push(4)
stack.push(78)
stack.items // [4, 78]
stack.pop()

stack.items // [4]

You can change value of items by creating instance of Stack. But without mutating keyword function can not change property.

### What is delegation pattern?

Ans :

A design pattern is a generalized way of arranging different parts of code. The main motive behind using a design pattern is to achieve better readability and code reusability.

Delegation is a design pattern that makes a component in code delegate its task(s) to a different component.

In order to make communication possible in two ways, we should use delegate. We can achieve this using delegate-protocol in Objective-C and Swift.

We should use delegate as Weak due to avoid memory leaks.