Category: Asynchronous

So, you’ve got this great app that does some pretty awesome stuff.  However, some of that stuff takes time. Perhaps its a network call, complex calculation of image manipulation, potentially time consuming cache clearing. Whatever it may be, you’ve noticed that your application is starting to lag or becomes completely unresponsive.  Shoot! What can we do about that?

GCD to the rescue!

GCD stands for Grand Central Dispatch. What a name! (It always makes me think of Grand Central Station). GCD was first released with OS X Snow Leopard for the purpose of solving the issues we mentioned above.  You see, it was when Snow Leopard was released, that computers started having multiple cores.  To take advantage of this, Apple produced GCD with enables developers to send tasks to the different cores on different threads.

The Basics

To allow a developer to access the different threads, GCD provides a dispatch queue called (ready for this?) DisptachQueue.  Here is the down low on DispatchQueue’s:

• Dispatch queue’s manages tasks you send them in a FIFO (first in, first out) order.
• Can be either serial (tasks finish sequently, 1,2,3…) or Concurrent (task can finish at any time (1,3,2,5,4…). Note they all start in a FIFO order, but serial queue’s only start the next task once the current one is finished.
•  There are three types of DispatchQueue’s:
  1.  Main. This runs on the main thread and is a serial queue. This is why things can lag if the main queue has too much work on it.
  2. Global queue’s.  These are concurrent queue’s which the OS shares with your application. These come in four priority types: high, default, low, background. Note: you don’t set the priority directly, instead you use the Quality of Service (QoS) property.  More on this in a second.
  3. Custom queue’s. These are either serial or concurrent and are user created. Eventually, these are handled by a global queue.

QoS

In order for the system to properly allocate threads and save on energy, there are a lot of properties you can set on a queue. These properties take a lot of tuning in order to achieve the desired/expected outcome.  In order to simplify this for developers, apple has released some base classes you can set on a queue which will provide the correct settings for these properties.  These are the Quality of Service classes. There are four of them:

1. User-Interactive. This class is used when you are doing work that needs to be done immediately for a good user experience, like UI updates and such.. The main thread is a User-interactive thread (hence why you do all your UI updates on the main thread.)
2. User-Initiated. For doing work which the user has started from the UI and is waiting for immediate results or for tasks that require completion for the user to continue. These are marked as a high priority global queue.
3. Utility. For long running computations. These types of queue’s often are accompanied by a progress indicator. E.G: computations, network calls, large image manipulation, etc.
4. Background. These are things that need to be done, but the user doesn’t need to know or worry about them.  Clearing up cache and prefetching are two such examples.

Lets Try it out!

Now that we know all this stuff thats go through some examples. Lets say we have a network call where we download an image or sets of images. Lets add an extension to UIImageView to do this:

extension UIImageViwe{
  public func imageFromServerURL(urlString: String, completionBlock:(()->())? = nil) {
        guard let URL = URL(string: urlString) else {return}
        do {
            let data = try Data.init(contentsOf: URL)
            let image = UIImage(data: data)
            self.image = image
        } catch {
            print("Crap I had an error");
        }
    }
}

If you do it this way, your app is libel to lag, as all the work is being done on the main thread.  Particularly if you have a slower internet connection. To fix this code, you can use dispatch queues:

extension UIImageView {

    public func imageFromServerURL(urlString: String, completionBlock:(()->())? = nil) {
        guard let URL = URL(string: urlString) else {return}
        DispatchQueue.global(qos: .userInitiated).async {
            do {
                let data = try Data.init(contentsOf: URL)
                let image = UIImage(data: data)
                DispatchQueue.main.async {
                    self.image = image
                }
            } catch {
                print("Crap I had an error");
            }
        }   
    }    
}

Now if you use this in say, a UITableViewCell that is duplicated many times, scrolling is snappy and pleasant!

Quick note: Dispatch queue propagate their QoS, meaning that if you create a dispatch queue and don’t specify the QoS it automatically applies the current QoS of the queue you are in.  There are two exceptions to this.  First, if launching from a UserInteractive, the default QoS is a user initiated.  This is done to not tie up the main thread accidentally. Secondly if moving from a lower thread (say background) to a thread that is higher in priority (say UserInitiated or UserInteractive) the higher QoS is applied.

This means that we could have simplified the above code by not specifying global(qos: .userInitiated), but just used global(), since we were on the main thread, global() would have created a thread with a UserInteractive QoS.

While the above code is OK for an example and teaching purposes, it would be better to use URLSession to fetch the image:

extension UIImageView {
    public func imageFromServerURL(urlString: String, completionBlock:(()->())? = nil) {
        guard let URL = URL(string: urlString) else {return}
        URLSession.shared.dataTask(with: URL , completionHandler: { (data, response, error) -> Void in
            
            if let unwrappedError = error {
                #if DEBUG
                    print(unwrappedError)
                #endif
                return
            }
            guard let unwrappedData = data else {return}
            DispatchQueue.main.async(execute: { () -> Void in
                let image = UIImage(data: unwrappedData)
                self.image = image
                if let unwrappedBlock = completionBlock {
                    unwrappedBlock()
                }
            })
        }).resume()
    }
}

Here is another example that I’ve needed to do.  One application I wrote (a sort of Instagram for hunters) would cache the images viewed by the user.  This was great for speeding up view times in various places of the app, however we quickly noticed that the app size ballooned to multiple gigabits. To combat this we decided to clear the cache every day or so.

DispatchQueue.global(qos: .background).async {
    //Clear cache
}

Note we use the background QoS.

TL;DR

/*
 QOS Types:
 .default - propogates current QoS (unless moving to higher or is UserInteractive
 
 .userInteractive - for UI work
 .userInitiated - for work needed to be done ASAP
 .utility - for long running, progress updating tasks
 .background - for tasks the user doesn't need to worry about
 
*/
DispatchQueue.global(qos: .default).async {
    // Do your work here
    
    // update the UI:
    DispatchQueue.main.async {
        // UI updates go here
    }
}

Readings and Examples:

Grand Central Dispatch Tutorial for Swift 3: Part 1/2

https://developer.apple.com/videos/play/wwdc2015/718/

https://developer.apple.com/videos/play/wwdc2016/720/