Grand Central Dispatch (GCD) in iOS development

Grand Central Dispatch (GCD) is a technology developed by Apple for managing concurrent operations in iOS, macOS, and watchOS.

Developers no longer need to manually establish and maintain threads when using GCD to carry out activities in the background.

GCD automatically manages task scheduling and resource allocation while utilising a combination of queues and blocks to run code concurrently. GCD is often used for tasks such as image processing, networking, and database operations that are performed asynchronously to improve the responsiveness and performance of an app.

Dispatch Queues

Dispatch Queues are a fundamental concept in Grand Central Dispatch (GCD) and are used to manage the execution of tasks. They offer a method for concurrently running code, enabling the execution of many tasks. A queue work in “FIFO” order, that is, first in, first out. The queue can be either Serial or Concurrent.

Types of DispatchQueue

There are several types of Dispatch Queues in GCD, that are divided into two main categories:

1. System-Defined Dispatch Queues:

1.1. Main Dispatch Queue: This is a serial queue that runs on the main thread and is responsible for executing all UI-related tasks.

Here is an example of how to use the Main Dispatch Queue in Swift:

DispatchQueue.main.async { 
  print("This is a UI task.")
}// Perform UI task here, such as updating a label or button

In this example, we use the mainQueue property of the DispatchQueue class, which is a reference to the Main Dispatch Queue. Then, we submit an asynchronous job using the async method for execution on the main thread.

Pros: Immediate execution on the main thread, which is responsible for handling user interactions and updating the UI.

Cons: Can block the main thread if used for long-running tasks, leading to a slow and unresponsive UI.

1.2. Global Dispatch Queues: These are concurrent queues that are shared by the system and are available to all applications.

Here is an example of how to use a Global Dispatch Queue in Swift:

DispatchQueue.global().async { // Perform background task here, like fetching data from server or images 
  print("This is a global background task.")
}

In this example, we build a reference to a global queue using the global() method of the DispatchQueue class.. Then we use the async method to submit an asynchronous task, which will be executed concurrently with the main thread.

Pros: Concurrent execution, which allows multiple tasks to run simultaneously, improving overall performance.

Cons: No guaranteed order of task execution, as tasks are executed in parallel and their order of completion is not guaranteed.

2. User-Defined Dispatch Queues:

2.1. Serial Dispatch Queues: These queues execute one task at a time, in the order they are added. Tasks are guaranteed to run in the order they were added to the queue.

Here is an example of how to use a Serial Dispatch Queuein Swift:

let serialQueue = DispatchQueue(label: "com.arvind.app.serialqueue")
// Asynchronous task 1
serialQueue.async {
  // Perform task 1 here
  print("This is task 1.")
}
// Asynchronous task 2
serialQueue.async {
  // Perform task 2 here
  print("This is task 2.")
}

In this example, we use the DispatchQueue initializer to create a new Serial Dispatch Queue with a label com.arvind.app.serialqueue. Then we use the async method to submit two asynchronous tasks, which will be executed one after the other on the serialQueue.

Additionally, you can submit synchronous tasks using the Serial DispatchQueue’s sync method. These tasks will be executed on the queue sequentially, waiting for each task to finish before moving on to the next.

serialQueue.sync {
  // Perform synchronous task here
  print("This is a synchronous task.")
}

It’s important to note that using sync method on a Serial DispatchQueue will cause the application to freeze if the task takes a long time to complete, or if it’s waiting for another task to complete.

Pros: Guaranteed order of task execution, as tasks are executed one after the other in the order they were added to the queue. Simplifies task management, as tasks are executed in a predictable order without the need for additional synchronization.

Cons: Serial execution can limit performance, as tasks are executed one after the other, reducing the overall throughput and May result in deadlocks if tasks depend on each other and wait for each other to complete, leading to a blocked queue.

2.2. Concurrent Dispatch Queues: These queues can execute multiple tasks simultaneously. Tasks are not guaranteed to run in the order they were added to the queue.

Here is an example of how to use a Concurrent Dispatch Queue in Swift:

let concurrentQueue = DispatchQueue(label: "com.arvind.app.concurrentqueue", attributes: .concurrent)
// Asynchronous task 1
concurrentQueue.async {
  // Perform task 1 here
  print("This is task 1.")
}
// Asynchronous task 2
concurrentQueue.async {
  // Perform task 2 here
  print("This is task 2.")
}

This example shows that Concurrent Dispatch Queues are useful for improving the performance of an app by allowing multiple tasks to run concurrently. Tasks are not guaranteed to run in the order they were added to the queue.

You can also use the sync method on the Concurrent DispatchQueue but it’s not recommended because it will block the current thread and will cause the application to freeze until the task is completed.

Pros: Multiple tasks can run simultaneously, which can improve performance and tasks can start executing as soon as they are added to the queue, without waiting for other tasks to complete.

Cons: No guaranteed order of task execution, as tasks are executed in parallel and their order of completion is not guaranteed, can lead to race conditions and data inconsistencies if multiple tasks access and modify shared resources without proper synchronization.

Additionally, there are also two types of DispatchQueue attributes, which can be used to specify the behavior of a queue:

QoS Class:

Quality of Service class is used to specify the relative priority of a task.

Autorelease Frequency: This attribute can be used to specify the frequency at which autorelease pools are created on the queue.

The QoS class can be one of the following :

• User Interactive: Used for animations or updating UI.
• User Initiated: The user directly requested this operation, and is likely waiting, but the UI itself is not desperate for a result.
• Utility: This OOS is used to execute tasks that doesn’t effect the Ul actively.
• Background: This OOS is used to execute maintenance, cleanup type of tasks and has the lowest priority.
• default- As the name implies, this is the default QoS and if you don’t provide any QOS to the GlobalQueue, it’ll be default.

You can create a DispatchQueue with a specific QoS class like that:

let backgroundQueue = DispatchQueue(label: "com.arvind.bgqueue", qos: .background)

In the example above, the backgroundQueue DispatchQueue is created with a label com.arvind.app.bgqueue and a QoS class of background, which will indicate that this queue contains tasks that are low priority.

Summary

Choose the appropriate queue based on the task’s requirements. For example, use the Main DispatchQueue for UI updates, a serial queue for tasks that require a specific execution order, and a global queue for general purpose tasks that can run concurrently.

Thank You !!!