How to switch from background queue to main queue?

If you're on a background thread and want to execute code on the main thread, you need to call async() again. However, this time, you do it on DispatchQueue.main, which is the main thread, rather than one of the global quality of service queues.

DispatchQueue.global(qos: .userInitiated).async {

    if let url = URL(string: urlString) {

        if let data = try? Data(contentsOf: url) {

            self.parse(json: data)

            return

        }

    }

    self.showError()

}

func showError() {

    DispatchQueue.main.async {

        let ac = UIAlertController(title: "Loading error", message: "There was a problem loading the feed; please check your connection and try again.", preferredStyle: .alert)

        ac.addAction(UIAlertAction(title: "OK", style: .default))

        self.present(ac, animated: true)

    }

}

Sof here, If I want to work with UI-related stuff, I must switch queue to main. So to execute that code under  DispatchQueue.main.async { } block.

Explain NSOPERATION Priority.

Ans : 

All operations may not be equally important. Setting the queuePriority property will promote or defer an operation in an NSOperationQueue according to the following rankings:

public enum NSOperationQueuePriority : Int {

    case VeryLow

    case Low

    case Normal

    case High

    case VeryHigh

}

The operations with high priority will be executed first.

let backgroundOperation = NSOperation()

backgroundOperation.queuePriority = .Low

let operationQueue = NSOperationQueue.mainQueue()

operationQueue.addOperation(backgroundOperation)

Difference between OperationQueue and DispatchGroup

Ans : 

You probably found yourself in a situation where you had to do a bunch of asynchronous tasks and you just wanted to get notified when all of them finish. There are two easy ways of doing this: DispatchGroup and OperationQueue. 

DispatchGroup :

DispatchGroups is probably the easiest way for you to know when a bunch of asynchronous calls is finished.  DispatchGroup is a part of GCD and in Swift 3 we got a nice swiftified GCD.

func getMovies(onCompleted: (([MovieItem]) -> ())?) {

    

    var result: [MovieItem] = []

    

    let dispatchGroup = DispatchGroup()

    

    for i in 1...5 {

        guard

            let urlString = DataSourceConstants.URLString(forPage: "\(i)")

            else {

                continue

        }

        

        dispatchGroup.enter()

        self.networkingProvider.restCall(urlString: urlString) {

            

            (responseObject) in

            

            guard

                let responseData = responseObject,

                let jsonObject = try? JSONSerialization.jsonObject(with: responseData, options: [JSONSerialization.ReadingOptions.allowFragments])

                else {

                    dispatchGroup.leave()

                    return

            }

            

            let movies = self.moviesFactory.movieItems(withJSON: jsonObject)

            result = result + movies

            

            dispatchGroup.leave()

        }

    }

    

    dispatchGroup.notify(queue: DispatchQueue.global()) {

        onCompleted?(result)

    }

}

Here we create your DispatchGroup at the top of the function and just before you execute an async piece of code, you enter the group. In your closure, you leave the same group just before the closure completes. When your DispatchGroup is empty, a closure will be called.

What’s really important here is the enter-leave pairs. You have to be very careful and make sure that you leave the group. It would be easy to introduce a bug in the code above. Let’s say that we didn’t leave the group in that guard statement above, just before the return. If the API called failed, or the JSON was malformed, the number of group entries would not match the number of leaves. So the group completion handler would never get called. If you’re calling this method from the UI and displaying an activity indicator while your networking requests are running, you would never get a callback from the method, and you would keep on spinning.

OperationQueue :

Operation queues are great and all, but if you just want to know when your queue is finished you won’t find a ready-made API waiting for you.

There is a simple trick you can use to get notified when your async tasks are finished. The trick is to use dependencies. You have two options here. If you need your operations to execute one after another, you can set the next operation to be dependent on the previous. So when your last operation is finished, your queue is finished as well. This is easy to do.

For concurrent operations(executing at same time),  Create another operation. Operations can have dependencies on multiple operations. So when you create your operations you add them as a dependency to that operation. When all dependent operation finish, your operation will get executed. And this way you can tell that your ‘queue’ is finished. If you think about this from a logical perspective, it makes perfect sense. Anyone can add a bunch of operations in the operation queue, and if you don’t own it completely, you don’t know who added what. So having a callback that will tell you that the queue is empty would not be very useful. Dependencies are baked into the Operations.

func getMovies(onCompleted: (([MovieItem]) -> ())?) {

    

    operationQueue.cancelAllOperations()

    

    var result: [MovieItem] = []

    

    let queueCompletionOperation = BlockOperation {

        onCompleted?(result)

    }

    

    var operations: [Operation] = []

    

    operationQueue.isSuspended = true

    

    for i in 1...5 {

        guard

            let urlString = DataSourceConstants.URLString(forPage: "\(i)")

            else {

                continue

        }

        

        let networkingOperation = GetDataOperation(withURLString: urlString, andNetworkingProvider: networkingProvider)

        let parsingOperation = ParseDataOperation(withFactory: moviesFactory)

        

        networkingOperation.completionBlock = {

            parsingOperation.moviesData = networkingOperation.responseData

        }

        

        parsingOperation.completionBlock = {

            if let moviesArray = parsingOperation.movies {

                DispatchQueue.global().sync(flags: .barrier) {

                    result = result + moviesArray

                }

            }

        }

        

        parsingOperation.addDependency(networkingOperation)

        

        queueCompletionOperation.addDependency(parsingOperation)

        

        operations.append(contentsOf: [parsingOperation, networkingOperation])

    }

    

    operations.append(queueCompletionOperation)

    

    operationQueue.addOperations(operations, waitUntilFinished: false)

    operationQueue.isSuspended = false

}

We have our ‘queueCompletionOperation’ at the top and in the block we’re calling our closure. We suspend the queue before adding new operations and we’re setting the dependency on our queueCompletionOperation to parsingOperation. After the loop is finished, we add all the operations in the queue and un-suspend the queue.

Dispatch queue :

A DispatchQueue is an abstraction layer on top of the GCD queue that allows you to perform tasks asynchronously and concurrently in your application. Tasks are always executed in the order they’re added to the queue.

There are two types of dispatch queues :

1. Serial Dispatch Queue

2. Concurrent Dispatch Queue

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 {

  // Add your serial task

 }

Download images using serial queue : 

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 {

 // write your code here

}

// Asynchronous

DispatchQueue.global().async {

 // write your code here

}

Let's create own concurrent queue using GCD: 

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

 concurrentQueue.async {

  // Add your concurrent task

 }

Download images using concurrent queue:

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 {

 // Event handling task

}

Multi threading, GCD, Operation Queue

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. The Grand Central Dispatch (GCD) is a is a low-level API provided by Apple. GCD is used for managing concurrent operations. GCD has lots of benefits like

– It improves application performance and responsiveness.
– The app will become more smooth.
– Execute multiple tasks at a time or one by one as per your requirements.
GCD operates at the system level, it is managing the resources in a balanced way for all running application.

GCD & Operation Queues help keep your app user interface responsive by running slow task of main queue.

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.

Learn more about QOS

For delaying task :

let delay = DispatchTime.now() + .seconds(60)
DispatchQueue.main.asyncAfter(deadline: delay) {
    // Dodge this!
}

Multi threading, GCD, Operation Queue

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