Aké spôsoby existujú na zabezpečenie bezpečnosti vlákien v iOS aplikáciách?

Pre zabezpečenia bezpečnosti vlákien v iOS sa používajú nasledujúce hlavné mechanizmy:

1. Mutex (medzivládne vylúčenie):

   • pthread_mutex_t: Nízkoúrové API z POSIX.
   • NSLock: Objektovo orientovaná obálka nad primitívmi zámkov, súčasť Foundation.
   • NSRecursiveLock: Umožňuje rekurzívne zamknutie rovnakým vláknom.

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

2. Spin Lock:

   • OSSpinLock: Zastaralý a nedoporučený kvôli problémom s prioritami a nadmernému využívaniu CPU pri dlhom čakaní. Nahradený os_unfair_lock.
   • os_unfair_lock: Efektívnejšia náhrada za OSSpinLock, časť os.xnu.

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

3. Semaphore (semafor):

   • DispatchSemaphore: Semafor z Grand Central Dispatch (GCD). Riadi prístup k zdroju pomocou čítača.

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Čítač = 1 (podobne ako mutex)
   var limitedResource = 0
   
   func accessLimitedResource() {
       semaphore.wait() // Znižuje čítač, blokuje ak <= 0
       // Kritická sekcia
       limitedResource += 1
       semaphore.signal() // Zvyšuje čítač
   }
   

4. Konkurentná fronta s barrier úlohami:

   • Použitie konkurentnej fronty (concurrent queue) v GCD na čítanie a zápis. Čítanie sa vykonáva paralelne (async), zápis - výlučne (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) {
           // Úloha s príznakom .barrier sa vykonáva výlučne
           protectedArray.append(item)
       }
   }
   
   func readArray() -> [Int] {
       var arrayCopy: [Int] = []
       concurrentQueue.sync {
           // Bežná synchronizovaná úloha (čítanie) môže byť paralelná s inými čítaniami
           arrayCopy = protectedArray
       }
       return arrayCopy
   }
   

5. Atomické operácie:

   • Nízkoúrovňové operácie, ktoré garantujú atomickosť (vykonávajú sa ako celok, bez prerušení). Používajú sa pre jednoduché typy dát (celé čísla, ukazovatele).

   import Darwin // Pre niektoré atomické funkcie, napríklad OSAtomic...
   
   var atomicCounter: Int32 = 0
   
   func incrementAtomicCounter() -> Int32 {
       // Príklad atomickej operácie
       return OSAtomicIncrement32(&atomicCounter)
   }
   

   • V Swifte existujú experimentálne typy Atomic<Value> v swift-atomics.

6. Thread Sanitizer:

   • Nástroj na ladenie, ktorý odhaľuje závody dát (data races) počas behu aplikácie. Aktivuje sa v schéme zostavovania Xcode (Edit Scheme -> Run -> Diagnostics -> Thread Sanitizer).

Výber mechanizmu závisí od úlohy:

• Jednoduchý exkluzívny prístup: NSLock, DispatchSemaphore(value: 1), os_unfair_lock.
• Rekurzívne zamknutie: NSRecursiveLock.
• Čítanie/zápis: Konkurenčná fronta s .barrier.
• Obmedzenie prístupu (pool zdrojov): DispatchSemaphore (s čítačom > 1).
• Jednoduché čítače/flagy: Atomické operácie (ak sú vhodné a vyžadujú maximálny výkon, s opatrnosťou).

Vyhnúť by sa malo:

• OSSpinLock.
• Používaniu globálnych zámkov bez potreby.
• Predčasnej optimalizácii pomocou primitives nízkeho úrovne bez pochopenia ich fungovania.