Swift Concurrency: Elevating App Performance

Welcome to the realm of Swift Concurrency, where your app’s performance takes center stage in a symphony of parallel operations. Imagine you’re in your kitchen, creating a delightful meal. As you wait for one dish to simmer, you effortlessly prepare a refreshing juice, maximizing your time and efficiency. Swift Concurrency operates in a similar fashion, allowing your app to perform multiple tasks simultaneously. In this blog, we’ll unravel the simplicity and power of Swift Concurrency through real-life examples, demonstrating how you can make the most out of every moment in your code. Let’s dive in and explore the art of parallelism that Swift brings to your app development kitchen!

Ensure your project supports Swift Concurrency, as this feature was introduced in Swift 5.5.

Let’s consider a simple example of a Swift app without concurrency. Imagine an app that downloads images from the internet and displays them in a table view.

import UIKit

class ImageDownloaderViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {

    @IBOutlet weak var tableView: UITableView!
    var imageURLs: [URL] = [...] // An array of image URLs

    override func viewDidLoad() {
        super.viewDidLoad()
        tableView.delegate = self
        tableView.dataSource = self
    }

    // MARK: - Table View Data Source

    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return imageURLs.count
    }

    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "ImageCell", for: indexPath)
        let imageURL = imageURLs[indexPath.row]
        
        // Synchronous Image Download (Without Concurrency)
        if let imageData = try? Data(contentsOf: imageURL),
           let image = UIImage(data: imageData) {
            cell.imageView?.image = image
        }
        
        return cell
    }
}

In this example, the cellForRow(at:) method synchronously downloads images from the given URLs one by one. While this approach is simple, it can lead to a sluggish user interface and potential freezing, especially when dealing with a large number of images or slow network conditions. Users might experience delays and unresponsiveness as each image is downloaded sequentially.

Understanding Concurrency in Swift

Let’s start with a simple example to understand concurrency in Swift. We’ll use a scenario of fetching data from two different sources concurrently. Imagine fetching weather data from an API and news headlines from another API.

import Foundation

// Asynchronous function to fetch weather data
func fetchWeather() async -> String {
    print("Fetching weather data...")
    // Simulate network delay
    await Task.sleep(2 * 1_000_000_000) // 2 seconds
    return "Sunny with a chance of clouds"
}

// Asynchronous function to fetch news headlines
func fetchNews() async -> String {
    print("Fetching news headlines...")
    // Simulate network delay
    await Task.sleep(3 * 1_000_000_000) // 3 seconds
    return "Breaking: Swift Concurrency Unleashed!"
}

// Main function to demonstrate concurrent fetching
func main() async {
    // Concurrently fetch weather and news
    let weatherTask = Task { await fetchWeather() }
    let newsTask = Task { await fetchNews() }

    // Wait for both tasks to complete
    let weatherResult = await weatherTask.value
    let newsResult = await newsTask.value

    // Process and print results
    print("Weather: \(weatherResult)")
    print("News: \(newsResult)")
}

// Run the main function
Task {
    await main()
}

In this example:

1. fetchWeather and fetchNews are asynchronous functions that simulate fetching data from different sources with a delay.
2. The main function concurrently initiates tasks to fetch weather and news using the Task API.
3. The await keyword is used to wait for both tasks to complete before moving on to process the results.
4. Finally, the results are printed.

This example illustrates how Swift concurrency allows tasks to run concurrently, enabling more efficient utilization of time, especially when tasks involve waiting for external resources, such as network requests. Now, as we move on to the enhanced image downloading example, keep in mind this basic understanding of concurrency.

Updating the Image Downloading Example using Async/Await:

As observed in the previous version, the app experienced unresponsiveness during image downloads. To address this, we will integrate async/await to make the image downloading process asynchronous.

Make Image Downloading Asynchronous:

Writing the async keyword in the method declaration indicates its asynchronous nature. Here's how we modify the image downloading function:

// Before
func downloadImage() -> UIImage {
    // Synchronous image download
    let imageData = try? Data(contentsOf: imageURL)
    return UIImage(data: imageData)
}

// After
func downloadImage() async -> UIImage {
    // Asynchronous image download using async/await
    do {
        let imageData = try await URLSession.shared.data(from: imageURL)
        return UIImage(data: imageData.data) ?? UIImage()
    } catch {
        print("Error downloading image: \(error)")
        return UIImage() // Return a placeholder image in case of an error
    }
}

Using Async/Await:

The await keyword is used in front of a method call, signifying a point where execution may be suspended. Here's how it looks in our example:

// Before
let image = downloadImage()

// After
let image = await downloadImage()

Handling Errors:

If an error occurs during asynchronous operations, Swift will throw an error. In our case, we catch and handle errors during image download:

// After
do {
    let image = await downloadImage()
    // Process the downloaded image
} catch {
    print("Error handling: \(error)")
}

Viewing Concurrency Errors:

In the process, errors may appear in parts of the code that don’t support concurrency. To resolve this, add the async keyword to the method declaration:

// Before
override func viewDidLoad() {
    // Existing code
}

// After
override async func viewDidLoad() {
    // Existing code
}

Handling Async Superclass Limitations:

If using async in the viewDidLoad method results in errors, it might be due to superclass limitations. Resolve by removing async from the method:

// After
override func viewDidLoad() {
    // Existing code
}

By incorporating async/await, the image downloading process becomes asynchronous, ensuring a more responsive app and smoother user experience during concurrent tasks.

Enhancing Image Download Efficiency using Async-Let in Swift Concurrency:

Despite achieving responsiveness during image downloads, the current implementation processes each image sequentially. To significantly boost efficiency, we’ll introduce async-let, a powerful feature of Swift Concurrency that enables parallel execution of asynchronous tasks.

Implementing Async-Let for Parallel Image Downloads:

Upgrade the Task block within the ViewController file to leverage async-let:

Task {
    let startTime = Date().timeIntervalSince1970

    async let image1 = downloadImage(from: imageURLs[0])
    async let image2 = downloadImage(from: imageURLs[1])
    async let image3 = downloadImage(from: imageURLs[2])

    await updateImageView(image1, at: 0)
    await updateImageView(image2, at: 1)
    await updateImageView(image3, at: 2)

    let endTime = Date().timeIntervalSince1970
    elapsedTimeLabel.text = "Elapsed time is \(((endTime - startTime) * 100).rounded() / 100) seconds"
}

Handling Multiple Image Downloads Concurrently:

Here, downloadImage(from:) is a function asynchronously fetching an image from a given URL, and updateImageView(_:at:) updates the image view at a specific index.

Observing Enhanced Efficiency:

Build and run the app to witness a notable reduction in elapsed time. Images are now downloaded concurrently, elevating the efficiency of your app.

(Replace “image_link” with the appropriate link to your image)

The improved elapsed time reflects the power of async-let, enabling multiple image downloads to occur simultaneously.

Congratulations! You’ve embarked on a journey through the dynamic landscape of Swift Concurrency, transforming your app’s performance into a symphony of parallel operations. In this blog, we’ve drawn parallels between coding and culinary artistry, illustrating how Swift Concurrency empowers your app to seamlessly execute multiple tasks concurrently — much like preparing a meal while waiting for a dish to simmer.

As we navigated through real-life examples, we witnessed the evolution of a basic image downloading app, learning how to transition from synchronous to asynchronous operations. With the introduction of async/await, your app became more responsive, handling concurrent tasks with grace and efficiency.

The journey didn’t end there; we further elevated the app’s performance by embracing async-let. This powerful tool allowed us to orchestrate parallel image downloads, reducing elapsed time and enhancing overall efficiency. Just as a chef efficiently juggles multiple tasks in the kitchen, Swift Concurrency empowers you to optimize every moment in your code.

As you continue refining your app development skills, remember that Swift Concurrency is a vast landscape with even more advanced features like structured concurrency and actors. Delve deeper into these concepts to unlock new dimensions in your coding repertoire.

Your app is now equipped to deliver a responsive and efficient user experience, thanks to the artistry of Swift Concurrency. Embrace these techniques, experiment with parallelism, and continue exploring the ever-evolving world of Swift. Happy coding!

If you found this blog helpful or have any questions, feel free to reach out to me on social media:

• YouTube: ElAmir’s YouTube Channel
• Facebook: ElAmir’s Facebook Page
• LinkedIn: Connect with ElAmir on LinkedIn
• Twitter: Follow ElAmir on Twitter
• Udemy: ElAmir’s Udemy Profile

I look forward to connecting with you and exploring more about Enums in Swift together! Thanks for reading.