Jaké způsoby existují, jak zajistit bezpečnost vláken v iOS aplikacích?

Pro zajištění bezpečnosti vláken v iOS se používají následující hlavní mechanismy:

1. Mutex (vzájemné vyloučení):

   • pthread_mutex_t: Nízkoúrové API z POSIX.
   • NSLock: Objektově orientovaná obálka nad primitivy zámků, součást Foundation.
   • NSRecursiveLock: Umožňuje rekurzivní zamčení stejným vláknem.

   import Foundation
   
   let lock = NSLock()
   var sharedResource = 0
   
   func modifySharedResource() {
       lock.lock()
       // Kritická sekce
       sharedResource += 1
       lock.unlock()
   }
   

2. Spin Lock:

   • OSSpinLock: Zastaralý a nedoporučený kvůli problémům s prioritami a nadměrnému využívání CPU při dlouhém čekání. Nahrazen os_unfair_lock.
   • os_unfair_lock: Efektivnější náhrada za OSSpinLock, součást os.xnu.

   import os.lock
   
   var unfairLock = os_unfair_lock()
   var anotherResource = 0
   
   func updateResource() {
       os_unfair_lock_lock(&unfairLock)
       // Kritická sekce
       anotherResource += 1
       os_unfair_lock_unlock(&unfairLock)
   }
   

3. Semaphore (semafory):

   • DispatchSemaphore: Semafor z Grand Central Dispatch (GCD). Řídí přístup ke zdroji pomocí čítače.

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Čítač = 1 (podobně jako mutex)
   var limitedResource = 0
   
   func accessLimitedResource() {
       semaphore.wait() // Snižuje čítač, blokuje pokud <= 0
       // Kritická sekce
       limitedResource += 1
       semaphore.signal() // Zvyšuje čítač
   }
   

4. Konkurenční fronta s barrier úkoly:

   • Použití konkurenční fronty v GCD pro čtení a zápis. Čtení se provádí paralelně (async), zápis exkluzivně (sync(flags: .barrier)).

   import Foundation
   
   let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)
   var protectedArray: [Int] = []
   
   func addItem(_ item: Int) {
       concurrentQueue.sync(flags: .barrier) {
           // Úkol s příznakem .barrier se provádí exkluzivně
           protectedArray.append(item)
       }
   }
   
   func readArray() -> [Int] {
       var arrayCopy: [Int] = []
       concurrentQueue.sync {
           // Obvyklý synchronní úkol (čtení) může být paralelní s jinými čteními
           arrayCopy = protectedArray
       }
       return arrayCopy
   }
   

5. Atomické operace:

   • Nízké úrovně operací, zajišťující atomovost (provádějí se jako celek, bez přerušení). Používají se pro jednoduché datové typy (celá čísla, ukazatele).

   import Darwin // Pro některé atomické funkce, například OSAtomic...
   
   var atomicCounter: Int32 = 0
   
   func incrementAtomicCounter() -> Int32 {
       // Příklad atomické operace
       return OSAtomicIncrement32(&atomicCounter)
   }
   

   • Ve Swiftu existují experimentální typy Atomic<Value> v swift-atomics.

6. Thread Sanitizer:

   • Nástroj pro ladění, který odhaluje závody dat (data races) během běhu aplikace. Aktivuje se v schématu sestavení Xcode (Edit Scheme -> Run -> Diagnostics -> Thread Sanitizer).

Výběr mechanismu závisí na úkolu:

• Jednoduchý exkluzivní přístup: NSLock, DispatchSemaphore(value: 1), os_unfair_lock.
• Rekurzivní zámek: NSRecursiveLock.
• Čtení/zápis: Konkurenční fronta s .barrier.
• Omezení přístupu (pool zdrojů): DispatchSemaphore (se čítačem > 1).
• Jednoduché čítače/flagy: Atomické operace (pokud jsou vhodné a vyžadují maximální výkon, opatrně).

Vyhnout se má:

• OSSpinLock.
• Použití globálních zámků bez potřeby.
• Předčasná optimalizace pomocí primitives nízké úrovně bez pochopení jejich fungování.