Welche Möglichkeiten gibt es, die Sicherheit von Threads in iOS-Anwendungen zu gewährleisten?

Um iOS verwendet die folgenden Hauptmechanismen, um die Thread-Sicherheit zu gewährleisten:

1. Mutex (wechselseitiger Ausschluss):

   • pthread_mutex_t: Low-Level-C-API aus POSIX.
   • NSLock: Objektorientierte Hülle über Sperrprimitive, Teil von Foundation.
   • NSRecursiveLock: Ermöglicht rekursives Sperren durch denselben Thread.

   import Foundation
   
   let lock = NSLock()
   var gemeinsamGenutzteRessource = 0
   
   func gemeinsameRessourceÄndern() {
       lock.lock()
       // Kritischer Abschnitt
       gemeinsamGenutzteRessource += 1
       lock.unlock()
   }
   

2. Spin Lock:

   • OSSpinLock: veraltet und nicht empfohlen wegen Prioritätsproblemen und hohem CPU-Verbrauch bei langer Wartezeit. Ersetzt durch os_unfair_lock.
   • os_unfair_lock: effizientere Alternative zu OSSpinLock, Teil von os.xnu.

   import os.lock
   
   var unfairLock = os_unfair_lock()
   var eineWeitereRessource = 0
   
   func RessourceAktualisieren() {
       os_unfair_lock_lock(&unfairLock)
       // Kritischer Abschnitt
       eineWeitereRessource += 1
       os_unfair_lock_unlock(&unfairLock)
   }
   

3. Semaphore:

   • DispatchSemaphore: Semaphore aus Grand Central Dispatch (GCD). Steuert den Zugriff auf eine Ressource über einen Zähler.

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Zähler = 1 (ähnlich einem Mutex)
   var limitierteRessource = 0
   
   func ZugriffAufLimitierteRessource() {
       semaphore.wait() // Verringert den Zähler, blockiert bei <= 0
       // Kritischer Abschnitt
       limitierteRessource += 1
       semaphore.signal() // Erhöht den Zähler
   }
   

4. Gleichzeitig laufende Warteschlange mit Barrier-Tasks:

   • Verwendung einer gleichzeitigen Warteschlange (concurrent queue) in GCD für Lesen und Schreiben. Lesen erfolgt parallel (async), Schreiben exklusiv (sync(flags: .barrier)).

   import Foundation
   
   let gleichzeitigeWarteschlange = DispatchQueue(label: "com.beispiel.concurrentQueue", attributes: .concurrent)
   var geschütztesArray: [Int] = []
   
   func ElementHinzufügen(_ item: Int) {
       gleichzeitigeWarteschlange.sync(flags: .barrier) {
           // Aufgabe mit .barrier-Flag, die exklusiv ausgeführt wird
           geschütztesArray.append(item)
       }
   }
   
   func ArrayLesen() -> [Int] {
       var arrayKopie: [Int] = []
       gleichzeitigeWarteschlange.sync {
           // Normale synchrone Aufgabe (Lesen), die parallel zu anderen Lesungen laufen kann
           arrayKopie = geschütztesArray
       }
       return arrayKopie
   }
   

5. Atomare Operationen:

   • Niedrigstufige Operationen, die die Atomarität garantieren (werden als unteilbare Einheit ausgeführt, ohne Unterbrechungen). Werden für einfache Datentypen (Ganzzahlen, Zeiger) verwendet.

   import Darwin // Für einige atomare Funktionen, z.B. OSAtomic...
   
   var atomarerZähler: Int32 = 0
   
   func InkrementiereAtomicZähler() -> Int32 {
       // Beispiel für eine atomare Operation
       return OSAtomicIncrement32(&atomarerZähler)
   }
   

   • In Swift gibt es experimentelle Typen Atomic<Value> in swift-atomics.

6. Thread Sanitizer:

   • Debugging-Tool, das Datenrennen (data races) während der Ausführung der Anwendung erkennt. Wird im Xcode-Buildschema aktiviert (Edit Scheme -> Run -> Diagnostics -> Thread Sanitizer).

Die Wahl des Mechanismus hängt von der Aufgabe ab:

• Einfache exklusive Zugriffe: NSLock, DispatchSemaphore(value: 1), os_unfair_lock.
• Rekursives Sperren: NSRecursiveLock.
• Lesen/Schreiben: Concurrent Queue mit .barrier.
• Zugriffsbegrenzung (Ressourcenschwimmbad): DispatchSemaphore (mit Zähler > 1).
• Einfache Zähler/Flags: Atomare Operationen (falls anwendbar und maximale Leistung erforderlich, aber vorsichtig).

Vermeiden:

• OSSpinLock.
• Verwendung globaler Sperren ohne Notwendigkeit.
• Vorzeitige Optimierung mit Low-Level-Primitiven ohne Verständnis ihrer Funktionsweise.