What is a race condition?

Race condition occurs when two or more threads or processes access a shared resource (such as a variable, file, or database) simultaneously, and the outcome depends on the order in which they execute. Due to the unpredictable order of access and data modification, the result can be incorrect or unexpected.

Example in iOS: Suppose we have a counter count that is being incremented simultaneously by two threads.

var count = 0

func incrementCount() {
    // Thread 1 reads count = 5
    // Thread 2 reads count = 5
    let currentCount = count
    // Thread 1 calculates newCount = 6
    // Thread 2 calculates newCount = 6
    let newCount = currentCount + 1
    // Thread 1 writes count = 6
    // Thread 2 writes count = 6 (overwriting Thread 1's result)
    count = newCount
}

// If two threads call incrementCount() simultaneously,
// the expected result is count = 2,
// but due to the race condition, count may become 1.

To prevent race conditions, synchronization mechanisms are used:

• Lock/Mutex: Blocks access to the resource while the thread uses it.

  import Foundation
  
  let lock = NSLock()
  var count = 0
  
  func incrementCount() {
      lock.lock() // Acquire lock
      let currentCount = count
      let newCount = currentCount + 1
      count = newCount
      lock.unlock() // Release lock
  }
  

• Queues: Using serial GCD queues.

  import Foundation
  
  let serialQueue = DispatchQueue(label: "com.myapp.counterQueue")
  var count = 0
  
  func incrementCount() {
      serialQueue.async {
          let currentCount = count
          let newCount = currentCount + 1
          count = newCount
      }
  }
  

• Atomic operations: Non-interruptible operations at the processor instruction level. In Swift, you can use OSAtomic... (deprecated) or Atomic from @_implementationOnly import Atomics (experimental), or approaches based on locks/queues.

The choice of synchronization method depends on the specific scenario and performance requirements. It is important to understand that synchronization can introduce additional overhead and potentially lead to deadlocks if implemented incorrectly.