Kokie būdai yra, kaip užtikrinti sriegių saugumą iOS programose?

iOS srauto saugumo užtikrinimui naudojami šie pagrindiniai mechanizmai:

1. Mutex (mūtuoks):

   • pthread_mutex_t: žemo lygio C API iš POSIX:
   • NSLock: objektinis blokavimo mechanizmas, Foundation dalis:
   • NSRecursiveLock: leidžia rekursinį blokavimą tą pačią srautą:

   import Foundation
   
   let lock = NSLock()
   var sharedResource = 0
   
   func modifySharedResource() {
       lock.lock()
       // Kritinė sekcija
       sharedResource += 1
       lock.unlock()
   }
   

2. Spin Lock:

   • OSSpinLock: pasenęs ir nerekomenduojamas dėl prioritetų problemų ir perteklinio CPU naudojimo ilgesnį laiką laukiančiuose:
   • os_unfair_lock: efektyvesnė alternatyva, OSSpinLock dalis, os.xnu:

   import os.lock
   
   var unfairLock = os_unfair_lock()
   var anotherResource = 0
   
   func updateResource() {
       os_unfair_lock_lock(&unfairLock)
       // Kritinė sekcija
       anotherResource += 1
       os_unfair_lock_unlock(&unfairLock)
   }
   

3. Semaphore (semaforas):

   • DispatchSemaphore: Grand Central Dispatch semaforas, valdymas prieigos prie išteklių skaitikliu:

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Skaitiklis = 1 (panašus į mūtuoką)
   var limitedResource = 0
   
   func accessLimitedResource() {
       semaphore.wait() // sumažina skaitiklį, blokuoja jei <= 0
       // Kritinė sekcija
       limitedResource += 1
       semaphore.signal() // padidina skaitiklį
   }
   

4. Lygiagretus eilė su barjerų užduotimis:

   • naudojama lygiagretinė eilė (concurrent queue) GCD, skaitymui ir rašymui:

   import Foundation
   
   let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)
   var protectedArray: [Int] = []
   
   func addItem(_ item: Int) {
       concurrentQueue.sync(flags: .barrier) {
           // užduotis su .barrier žyma vykdoma išskirtinai
           protectedArray.append(item)
       }
   }
   
   func readArray() -> [Int] {
       var arrayCopy: [Int] = []
       concurrentQueue.sync {
           // įprasta sinchroninė užduotis (skaitymas) gali būti vykdoma paraleliai su kitais skaitymais
           arrayCopy = protectedArray
       }
       return arrayCopy
   }
   

5. Atomarinės operacijos:

   • žemo lygio operacijos, garantuojančios atomarumą (vykdomos kaip vienetas, be pertraukų):

   import Darwin // kai kurios atomarinės funkcijos, pvz., OSAtomic...
   
   var atomicCounter: Int32 = 0
   
   func incrementAtomicCounter() -> Int32 {
       // pavyzdys atomarinės operacijos
       return OSAtomicIncrement32(&atomicCounter)
   }
   

   • Swift turi eksperimentinius Atomic<Value> tipus swift-atomics bibliotekoje:

6. Gijos sanitizatorius:

   • įrankis, kuris aptinka duomenų lenktynes (data races) vykdymo metu:

Mechanizmo pasirinkimas priklauso nuo užduoties:

• Paprastas išskirtinis prieigos būdas: NSLock, DispatchSemaphore(value: 1), os_unfair_lock:
• Rekursyvus užraktas: NSRecursiveLock:
• Skaitymas/rašymas: lygiagretinė eilė su .barrier:
• Prieigos apribojimas (resursų pulas): DispatchSemaphore (skaitiklis > 1):
• Paprasti skaitikliai/ženkliai: atomarinės operacijos (jei taikoma ir reikalinga maksimalus našumas, būkite atsargūs):

Reikėtų vengti:

• OSSpinLock:
• naudoti globalius užraktus be būtinybės:
• ankstyvas optimizavimas naudojant žemo lygio primitivius be jų darbo supratimo.