Millised on viis, kuidas tagada iOS rakendustes niitide turvalisus?

iOS turvalisuse tagamiseks kasutatakse järgmisi põhimehhanisme:

1. Mutex (müütoks):

   • pthread_mutex_t: madala taseme C API POSIX-ist:
   • NSLock: objektorienteeritud lukustusmehhanism, Foundation osa:
   • NSRecursiveLock: võimaldab rekursiivset lukustamist samast lõngast:

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

2. Spin Lock:

   • OSSpinLock: vananenud ja soovitatav mitte, probleemide tõttu prioriteetidega ja liigse CPU kasutamisega ooteajal:
   • os_unfair_lock: tõhusam alternatiiv, osa os.xnu-st:

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

3. Semaphore (semafor):

   • DispatchSemaphore: Grand Central Dispatch semafor, ressursile juurdepääsu kontrollimiseks loenduriga:

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Loendur = 1 (sarnane müütuokile)
   var limitedResource = 0
   
   func accessLimitedResource() {
       semaphore.wait() // vähendab loendurit, blokeerib kui <= 0
       // Kriitiline sektsioon
       limitedResource += 1
       semaphore.signal() // suurendab loendurit
   }
   

4. Konkurentsivõimeline järjekord (concurrent queue) ja barrier ülesanded:

   • Kasutades GCD konkurentsivõimelist järjekorda (concurrent queue) lugemiseks ja kirjutamiseks:

   import Foundation
   
   let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)
   var protectedArray: [Int] = []
   
   func addItem(_ item: Int) {
       concurrentQueue.sync(flags: .barrier) {
           // Barjääri märgisega ülesanne täidetakse eksklusiivselt
           protectedArray.append(item)
       }
   }
   
   func readArray() -> [Int] {
       var arrayCopy: [Int] = []
       concurrentQueue.sync {
           // Tavaline sünkroonne ülesanne (lugemine) võib olla paralleelne teiste lugemistega
           arrayCopy = protectedArray
       }
       return arrayCopy
   }
   

5. Atomaarsed operatsioonid:

   • Madala taseme operatsioonid, mis tagavad atomaarsuse (täidetakse kui üks tervik, katkestusteta):

   import Darwin // Mõned atomaarsed funktsioonid, näiteks OSAtomic...
   
   var atomicCounter: Int32 = 0
   
   func incrementAtomicCounter() -> Int32 {
       // Näide atomaarsest operatsioonist
       return OSAtomicIncrement32(&atomicCounter)
   }
   

   • Swiftis on eksperimentaalsed tüübid Atomic<Value> swift-atomics raamatukogus:

6. Giti sanitiseerija:

   • Tööriist, mis avastab andmerattad (data races) töö ajal:

Mehhanismi valik sõltub ülesandest:

• Lihtne eksklusiivne juurdepääs: NSLock, DispatchSemaphore(value: 1), os_unfair_lock:
• Rekursiivne lukustus: NSRecursiveLock:
• Lugemine/kirjutamine: konkurentsivõimeline järjekord koos .barrier-ga:
• Juurdepääsu piirang (ressursside pult): DispatchSemaphore (loendur > 1):
• Lihtsad loendurid/lipud: Atomaarsed operatsioonid (kui sobib ja nõutav maksimaalne jõudlus):

Vältida tuleks:

• OSSpinLock:
• Globaalsete lukustuste kasutamist ilma vajaduseta:
• Varajast optimeerimist madala taseme primitiivide kasutamisega, ilma nende töö mõistmiseta.