Welke methoden bestaan er om de veiligheid van threads in iOS-applicaties te waarborgen?

Om de threadveiligheid op iOS te waarborgen, worden de volgende hoofdmechanismen gebruikt:

1. Mutex (mutual exclusion):

   • pthread_mutex_t: Low-level C API van POSIX.
   • NSLock: objectgeoriënteerde wrapper over lock-primitieven, onderdeel van Foundation.
   • NSRecursiveLock: staat recursieve locking toe door dezelfde thread.

   import Foundation
   
   let lock = NSLock()
   var gedeeldeBron = 0
   
   func wijzigGedeeldeBron() {
       lock.lock()
       // Kritieke sectie
       gedeeldeBron += 1
       lock.unlock()
   }
   

2. Spin Lock:

   • OSSpinLock: verouderd en niet aanbevolen vanwege prioriteitsproblemen en overmatig CPU-verbruik bij lange wachttijden. Vervangen door os_unfair_lock.
   • os_unfair_lock: efficiënter alternatief voor OSSpinLock, onderdeel van os.xnu.

   import os.lock
   
   var unfairLock = os_unfair_lock()
   var nogEenBron = 0
   
   func updateBron() {
       os_unfair_lock_lock(&unfairLock)
       // Kritieke sectie
       nogEenBron += 1
       os_unfair_lock_unlock(&unfairLock)
   }
   

3. Semaphore:

   • DispatchSemaphore: semaphore uit Grand Central Dispatch (GCD). Beheert toegang tot een bron via een teller.

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Teller = 1 (gelijkaardig aan mutex)
   var beperkteBron = 0
   
   func toegangBeperkteBron() {
       semaphore.wait() // Vermindert de teller, blokkeert indien <= 0
       // Kritieke sectie
       beperkteBron += 1
       semaphore.signal() // Verhoogt de teller
   }
   

4. Gelijktijdige wachtrij met barrier-taken:

   • Gebruik van een gelijktijdige queue in GCD voor lezen en schrijven. Lezen wordt parallel uitgevoerd (async), schrijven exclusief (sync(flags: .barrier)).

   import Foundation
   
   let gelijktijdigeQueue = DispatchQueue(label: "com.voorbeeld.gelijktijdigeQueue", attributes: .concurrent)
   var beschermdArray: [Int] = []
   
   func voegItemToe(_ item: Int) {
       gelijktijdigeQueue.sync(flags: .barrier) {
           // Taak met .barrier-vlag wordt exclusief uitgevoerd
           beschermdArray.append(item)
       }
   }
   
   func leesArray() -> [Int] {
       var kopieArray: [Int] = []
       gelijktijdigeQueue.sync {
           // Normale synchronisatie taak (lezen) kan parallel met andere lezingen
           kopieArray = beschermdArray
       }
       return kopieArray
   }
   

5. Atomische operaties:

   • Laag-niveau operaties die atomariteit garanderen (worden als één geheel uitgevoerd, zonder onderbrekingen). Gebruikt voor eenvoudige datatypes (integers, pointers).

   import Darwin // Voor sommige atomische functies, zoals OSAtomic...
   
   var atomischeTeller: Int32 = 0
   
   func verhoogAtomischeTeller() -> Int32 {
       // Voorbeeld van een atomische operatie
       return OSAtomicIncrement32(&atomischeTeller)
   }
   

   • In Swift zijn er experimentele types Atomic<Value> in swift-atomics.

6. Thread Sanitizer:

   • Hulpmiddel voor debugging dat data races detecteert tijdens de uitvoering van de applicatie. Ingeschakeld in het Xcode schema (Edit Scheme -> Run -> Diagnostics -> Thread Sanitizer).

De keuze van mechanisme hangt af van de taak:

• Eenvoudige exclusieve toegang: NSLock, DispatchSemaphore(value: 1), os_unfair_lock.
• Recursieve lock: NSRecursiveLock.
• Lezen / schrijven: Gelijktijdige queue met .barrier.
• Toegangsbeperking (resource pool): DispatchSemaphore (met teller > 1).
• Eenvoudige tellers / flags: Atomische operaties (indien van toepassing en maximale prestaties vereist, wees voorzichtig).

Vermijd:

• OSSpinLock.
• Gebruik van globale locks zonder noodzaak.
• Vroegtijdige optimalisatie met laag-niveau primitieve zonder begrip van hun werking.