Task Queues in Swift: A Practical Guide

Working with Task Queues in Swift: From Theory to Real Projects

In modern iOS and macOS development, interface responsiveness is a key factor in application success. Every time you perform a heavy operation (loading an image, parsing JSON, working with a database) on the main thread, the user sees interface "freezing." The solution is task queues. In this article, we will cover three main approaches to working with queues in Swift: classic GCD, high-level OperationQueue, and modern async/await. You will get ready-to-use code examples and learn which approach to choose for a specific task.

1. Grand Central Dispatch (GCD): Quick Start with DispatchQueue

Grand Central Dispatch is a low-level library for managing concurrent code execution. It is the foundation of multithreading in Swift and remains the most performant tool for simple background tasks.

Main Queue Types:

\n
• main — serial queue of the main thread (all UI updates only here).
\n
• global(qos:) — concurrent queues with priorities (userInteractive, userInitiated, utility, background).
\n
• custom(label:) — your own queue (can be serial or concurrent).
\n

Example: Loading an Image and Updating the UI

import UIKit\n\nclass ImageLoader {\n    func loadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {\n        DispatchQueue.global(qos: .userInitiated).async {\n            guard let data = try? Data(contentsOf: url),\n                  let image = UIImage(data: data) else {\n                DispatchQueue.main.async {\n                    completion(nil)\n                }\n                return\n            }\n            DispatchQueue.main.async {\n                completion(image)\n            }\n        }\n    }\n}

Practical Tip: Always use .userInitiated for tasks the user expects immediately (e.g., opening an image). For background data synchronization, use .background.

2. OperationQueue: Managing Dependencies and Canceling Tasks

When the logic becomes more complex (need to cancel a task, set execution order, or limit the number of parallel operations), OperationQueue comes to the rescue. Unlike GCD, operations are objects that can be reused and controlled.

Key Features:

\n
• Task cancellation via cancel().
\n
• Dependencies (addDependency) — task B will execute only after task A.
\n
• Control over the maximum number of concurrent operations (maxConcurrentOperationCount).
\n

Example: Downloading Multiple Images with Concurrency Limitation

import UIKit\n\nclass BatchImageDownloader {\n    private let queue: OperationQueue = {\n        let q = OperationQueue()\n        q.maxConcurrentOperationCount = 3 // No more than 3 downloads simultaneously\n        q.qualityOfService = .userInitiated\n        return q\n    }()\n    \n    func downloadImages(from urls: [URL], completion: @escaping ([UIImage]) -> Void) {\n        var images: [UIImage] = []\n        let syncQueue = DispatchQueue(label: "sync.images")\n        \n        let finishOperation = BlockOperation {\n            DispatchQueue.main.async {\n                completion(images)\n            }\n        }\n        \n        for url in urls {\n            let operation = BlockOperation {\n                guard let data = try? Data(contentsOf: url),\n                      let image = UIImage(data: data) else { return }\n                syncQueue.async {\n                    images.append(image)\n                }\n            }\n