What is Grand Central Dispatch and how is it used in iOS development?

Grand Central Dispatch (GCD) — a low-level API for managing multithreading, providing a pool of system threads and scheduling tasks on them.

Main concepts of GCD:

• Dispatch Queues: Queues where blocks of code (tasks) are placed for execution.
  • Serial Queues: Execute blocks in the order they are added, one at a time.
  • Concurrent Queues: Execute blocks in parallel, but in the order they are added.
• Tasks (Blocks): Units of work sent to Dispatch Queues.
• Dispatch Sources: Monitoring system events (files, sockets, signals), triggering execution of blocks when they occur.

Used for:

1. Performing background operations: Loading data from the network, image processing, complex calculations, to avoid blocking the main thread (UI).

   DispatchQueue.global(qos: .userInitiated).async {
       // Performing resource-intensive operation
       let processedData = performHeavyProcessing()
   
       DispatchQueue.main.async {
           // Updating UI on the main thread
           updateUI(with: processedData)
       }
   }
   

2. Scheduling tasks: Delayed execution or periodic execution.

   DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
       // This code will execute after 2 seconds
       print("Delayed execution")
   }
   

3. Synchronizing access to data: Using serial queues or DispatchQueue.concurrentPerform to control parallel access.

   let syncQueue = DispatchQueue(label: "com.myapp.syncdatasource", attributes: .concurrent)
   var sharedArray = [Int]()
   
   func addItem(_ item: Int) {
       syncQueue.async(flags: .barrier) { // Using .barrier for exclusive access during write
           sharedArray.append(item)
       }
   }
   
   func processItems() {
       syncQueue.sync { // Synchronous read
           for item in sharedArray {
               print(item)
           }
       }
   }
   

Advantages over manual thread management (POSIX threads):

• Ease of use: Higher level of abstraction.
• Efficiency: GCD manages the pool of system threads more optimally, reducing overhead.
• Scalability: Automatically adapts to the number of processor cores.

QoS (Quality of Service) types: Defines task priority for the GCD scheduler.

QoS	Application
userInteractive	UI updates, animations, quick response
userInitiated	Tasks initiated by the user, requiring quick completion (loading, photo processing)
default	Default priority, between userInitiated and utility
utility	Long-running tasks without urgency (loading, indexing)
background	Tasks not visible to the user (backup, background synchronization)
unspecified	Priority not set, determined by the system