I am Boris Dobretsov, and this is the sixth part of a series Understanding Parallel Programming: A Guide for Beginners. If you haven’t read the first five parts, have a look at Understanding Parallel Programming: A Guide for Beginners, Understanding Parallel Programming: A Guide for Beginners, Part II, Understanding Threads to Better Manage Threading in iOS, Understanding Parallel Programming: Thread Management for Beginners, How Grand Central Dispatch Library Helps Organise Threads. Executing multiple code blocks in parallel may seem straightforward. However, writing concurrent code is often regarded as one of the most challenging aspects of programming. The complexity appears not only from running tasks in separate threads but also from ensuring they interact correctly with shared data. In this article, we’ll explore real-world scenarios and their solutions. Offloading Intensive UI Tasks to the Background Thread A common problem in mobile development is offloading heavy computations from the main thread to prevent UI freezes. Typically, these tasks don't require synchronization with others but must reflect their results back in the main thread. Consider this example: rendering a table view with images, applying a blur effect to each image. override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "SomeCell", for: indexPath)
    
    let inputImage = UIImage(named: "treeSmall")!
    let inputCIImage = CIImage(image: inputImage)!
    
    let blurFilter = CIFilter(name: "CIGaussianBlur", parameters: [kCIInputImageKey: inputCIImage])!
    let outputImage = blurFilter.outputImage!
    let context = CIContext()
    let cgiImage = context.createCGImage(outputImage, from: outputImage.extent)
    
    cell.imageView?.image = UIImage(cgImage: cgiImage!)
    return cell
} Running this will result in slow loading and laggy scrolling, even with just 10 rows and small images. Why? Applying a blur effect is computationally expensive. Let's refactor this to offload the task to a background thread: func blur(image: UIImage, for imageView: UIImageView) {
    DispatchQueue.global(qos: .userInteractive).async {
        let inputCIImage = CIImage(image: image)!
        let blurFilter = CIFilter(name: "CIGaussianBlur", parameters: [kCIInputImageKey: inputCIImage])!
        let outputImage = blurFilter.outputImage!
        let context = CIContext()
        let cgiImage = context.createCGImage(outputImage, from: outputImage.extent)
        let blurredImage = UIImage(cgImage: cgiImage!)

        DispatchQueue.main.async {
            imageView.image = blurredImage
        }
    }
} This eliminates lag and ensures the UI updates are performed in the main thread, adhering to threading rules. Waiting for Parallel Tasks to Complete Sometimes, we need to perform an action only after several parallel tasks have finished. Using our earlier example, the blur operation could trigger repeatedly during scrolling. To fix this, we'll blur all images in parallel and update the table view once all tasks are complete. var images = Array(repeating: UIImage(named: "treeSmall")!, count: 10)

func blurImages() {
    let dispatchGroup = DispatchGroup()
    var blurredImages = images
    
    for (index, image) in images.enumerated() {
        dispatchGroup.enter()
        DispatchQueue.global().async {
            let inputCIImage = CIImage(image: image)!
            let blurFilter = CIFilter(name: "CIGaussianBlur", parameters: [kCIInputImageKey: inputCIImage])!
            let outputImage = blurFilter.outputImage!
            let context = CIContext()
            let cgiImage = context.createCGImage(outputImage, from: outputImage.extent)
            blurredImages[index] = UIImage(cgImage: cgiImage!)
            dispatchGroup.leave()
        }
    }
    
    dispatchGroup.notify(queue: .main) {
        self.images = blurredImages
        self.tableView.reloadData()
    }
} Race Conditions: The Subtle Bug Lurking in Parallel Code Race conditions occur when multiple threads access shared data without proper synchronization, leading to unpredictable behavior. Let’s explore a simple example of assigning unique IDs to documents. Here’s a straightforward implementation: struct Document: CustomStringConvertible {
    let id: Int
    let name: String
    var description: String { "\(id) - \(name)" }
}

for charCode in UnicodeScalar("A").value...UnicodeScalar("Z").value {
    let docName = String(UnicodeScalar(charCode)!)
    let lastId = documents.last?.id ?? 0
    documents.append(Document(id: lastId + 1, name: docName))
} In a multithreaded setup, the above approach fails as multiple threads simultaneously read the same lastId. To fix this, we’ll use a thread-safe document store. Implementing a Thread-Safe Data Structure We’ll create a thread-safe document store using DispatchQueue. class DocumentStore: CustomStringConvertible {
    private var documents = [Document]()
    private let syncQueue = DispatchQueue(label: "syncQueue", attributes: .concurrent)

    func append(document: Document) {
        syncQueue.async(flags: .barrier) {
            self.documents.append(document)
        }
    }

    var description: String {
        var result = ""
        syncQueue.sync {
            result = self.documents.map { $0.description }.joined(separator: ", ")
        }
        return result
    }
} The .barrier flag ensures write operations are isolated, while reads can occur in parallel. Using this, our document generation works reliably. By combining these techniques, you can tackle synchronization challenges, optimize performance, and prevent vague bugs like race conditions. Mastering concurrency takes time and effort, but practice and experimentation are your strongest allies on this journey! I am Boris Dobretsov, and this is the sixth part of a series Understanding Parallel Programming: A Guide for Beginners. If you haven’t read the first five parts, have a look at Understanding Parallel Programming: A Guide for Beginners, Understanding Parallel Programming: A Guide for Beginners, Part II , Understanding Threads to Better Manage Threading in iOS , Understanding Parallel Programming: Thread Management for Beginners, How Grand Central Dispatch Library Helps Organise Threads. Understanding Parallel Programming: A Guide for Beginners , Understanding Parallel Programming: A Guide for Beginners Understanding Parallel Programming: A Guide for Beginners, Part II Understanding Parallel Programming: A Guide for Beginners, Part II Understanding Threads to Better Manage Threading in iOS Understanding Threads to Better Manage Threading in iOS Understanding Parallel Programming: Thread Management for Beginners , Understanding Parallel Programming: Thread Management for Beginners How Grand Central Dispatch Library Helps Organise Threads . How Grand Central Dispatch Library Helps Organise Threads Executing multiple code blocks in parallel may seem straightforward. However, writing concurrent code is often regarded as one of the most challenging aspects of programming. The complexity appears not only from running tasks in separate threads but also from ensuring they interact correctly with shared data. In this article, we’ll explore real-world scenarios and their solutions . real-world scenarios and their solutions Offloading Intensive UI Tasks to the Background Thread A common problem in mobile development is offloading heavy computations from the main thread to prevent UI freezes. Typically, these tasks don't require synchronization with others but must reflect their results back in the main thread. Consider this example: rendering a table view with images, applying a blur effect to each image. override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "SomeCell", for: indexPath)
    
    let inputImage = UIImage(named: "treeSmall")!
    let inputCIImage = CIImage(image: inputImage)!
    
    let blurFilter = CIFilter(name: "CIGaussianBlur", parameters: [kCIInputImageKey: inputCIImage])!
    let outputImage = blurFilter.outputImage!
    let context = CIContext()
    let cgiImage = context.createCGImage(outputImage, from: outputImage.extent)
    
    cell.imageView?.image = UIImage(cgImage: cgiImage!)
    return cell
} override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "SomeCell", for: indexPath)
    
    let inputImage = UIImage(named: "treeSmall")!
    let inputCIImage = CIImage(image: inputImage)!
    
    let blurFilter = CIFilter(name: "CIGaussianBlur", parameters: [kCIInputImageKey: inputCIImage])!
    let outputImage = blurFilter.outputImage!
    let context = CIContext()
    let cgiImage = context.createCGImage(outputImage, from: outputImage.extent)
    
    cell.imageView?.image = UIImage(cgImage: cgiImage!)
    return cell
} Running this will result in slow loading and laggy scrolling, even with just 10 rows and small images. Why? Applying a blur effect is computationally expensive. Let's refactor this to offload the task to a background thread: func blur(image: UIImage, for imageView: UIImageView) {
    DispatchQueue.global(qos: .userInteractive).async {
        let inputCIImage = CIImage(image: image)!
        let blurFilter = CIFilter(name: "CIGaussianBlur", parameters: [kCIInputImageKey: inputCIImage])!
        let outputImage = blurFilter.outputImage!
        let context = CIContext()
        let cgiImage = context.createCGImage(outputImage, from: outputImage.extent)
        let blurredImage = UIImage(cgImage: cgiImage!)

        DispatchQueue.main.async {
            imageView.image = blurredImage
        }
    }
} func blur(image: UIImage, for imageView: UIImageView) {
    DispatchQueue.global(qos: .userInteractive).async {
        let inputCIImage = CIImage(image: image)!
        let blurFilter = CIFilter(name: "CIGaussianBlur", parameters: [kCIInputImageKey: inputCIImage])!
        let outputImage = blurFilter.outputImage!
        let context = CIContext()
        let cgiImage = context.createCGImage(outputImage, from: outputImage.extent)
        let blurredImage = UIImage(cgImage: cgiImage!)

        DispatchQueue.main.async {
            imageView.image = blurredImage
        }
    }
} This eliminates lag and ensures the UI updates are performed in the main thread, adhering to threading rules. Waiting for Parallel Tasks to Complete Sometimes, we need to perform an action only after several parallel tasks have finished. Using our earlier example, the blur operation could trigger repeatedly during scrolling. To fix this, we'll blur all images in parallel and update the table view once all tasks are complete. var images = Array(repeating: UIImage(named: "treeSmall")!, count: 10)

func blurImages() {
    let dispatchGroup = DispatchGroup()
    var blurredImages = images
    
    for (index, image) in images.enumerated() {
        dispatchGroup.enter()
        DispatchQueue.global().async {
            let inputCIImage = CIImage(image: image)!
            let blurFilter = CIFilter(name: "CIGaussianBlur", parameters: [kCIInputImageKey: inputCIImage])!
            let outputImage = blurFilter.outputImage!
            let context = CIContext()
            let cgiImage = context.createCGImage(outputImage, from: outputImage.extent)
            blurredImages[index] = UIImage(cgImage: cgiImage!)
            dispatchGroup.leave()
        }
    }
    
    dispatchGroup.notify(queue: .main) {
        self.images = blurredImages
        self.tableView.reloadData()
    }
} var images = Array(repeating: UIImage(named: "treeSmall")!, count: 10)

func blurImages() {
    let dispatchGroup = DispatchGroup()
    var blurredImages = images
    
    for (index, image) in images.enumerated() {
        dispatchGroup.enter()
        DispatchQueue.global().async {
            let inputCIImage = CIImage(image: image)!
            let blurFilter = CIFilter(name: "CIGaussianBlur", parameters: [kCIInputImageKey: inputCIImage])!
            let outputImage = blurFilter.outputImage!
            let context = CIContext()
            let cgiImage = context.createCGImage(outputImage, from: outputImage.extent)
            blurredImages[index] = UIImage(cgImage: cgiImage!)
            dispatchGroup.leave()
        }
    }
    
    dispatchGroup.notify(queue: .main) {
        self.images = blurredImages
        self.tableView.reloadData()
    }
} Race Conditions: The Subtle Bug Lurking in Parallel Code Race conditions occur when multiple threads access shared data without proper synchronization, leading to unpredictable behavior. Let’s explore a simple example of assigning unique IDs to documents. Here’s a straightforward implementation: struct Document: CustomStringConvertible {
    let id: Int
    let name: String
    var description: String { "\(id) - \(name)" }
}

for charCode in UnicodeScalar("A").value...UnicodeScalar("Z").value {
    let docName = String(UnicodeScalar(charCode)!)
    let lastId = documents.last?.id ?? 0
    documents.append(Document(id: lastId + 1, name: docName))
} struct Document: CustomStringConvertible {
    let id: Int
    let name: String
    var description: String { "\(id) - \(name)" }
}

for charCode in UnicodeScalar("A").value...UnicodeScalar("Z").value {
    let docName = String(UnicodeScalar(charCode)!)
    let lastId = documents.last?.id ?? 0
    documents.append(Document(id: lastId + 1, name: docName))
} In a multithreaded setup, the above approach fails as multiple threads simultaneously read the same lastId . To fix this, we’ll use a thread-safe document store. lastId Implementing a Thread-Safe Data Structure We’ll create a thread-safe document store using DispatchQueue . DispatchQueue class DocumentStore: CustomStringConvertible {
    private var documents = [Document]()
    private let syncQueue = DispatchQueue(label: "syncQueue", attributes: .concurrent)

    func append(document: Document) {
        syncQueue.async(flags: .barrier) {
            self.documents.append(document)
        }
    }

    var description: String {
        var result = ""
        syncQueue.sync {
            result = self.documents.map { $0.description }.joined(separator: ", ")
        }
        return result
    }
} class DocumentStore: CustomStringConvertible {
    private var documents = [Document]()
    private let syncQueue = DispatchQueue(label: "syncQueue", attributes: .concurrent)

    func append(document: Document) {
        syncQueue.async(flags: .barrier) {
            self.documents.append(document)
        }
    }

    var description: String {
        var result = ""
        syncQueue.sync {
            result = self.documents.map { $0.description }.joined(separator: ", ")
        }
        return result
    }
} The .barrier flag ensures write operations are isolated, while reads can occur in parallel. Using this, our document generation works reliably. .barrier By combining these techniques, you can tackle synchronization challenges, optimize performance, and prevent vague bugs like race conditions. Mastering concurrency takes time and effort, but practice and experimentation are your strongest allies on this journey!

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Synchronization Challenges in Multithreading

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Developers Keep Ruining Apps with This Simple UI Blunder

Why Gemini 3.0 is a Great Builder But Still Needs a Human in the Loop

Swift Concurrency: Part 2 — Parent/child Relationship, Automatic Cancellation, Task Groups

Programmable Credit Cards: The Next Frontier Connecting DeFi With Real World UX

The Essential Guide to Relearning Java Thread Primitives

A Guide to Improving Your Python Performance Speed

Developers Keep Ruining Apps with This Simple UI Blunder

Why Gemini 3.0 is a Great Builder But Still Needs a Human in the Loop

Swift Concurrency: Part 2 — Parent/child Relationship, Automatic Cancellation, Task Groups

Programmable Credit Cards: The Next Frontier Connecting DeFi With Real World UX

The Essential Guide to Relearning Java Thread Primitives

A Guide to Improving Your Python Performance Speed

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps