Kādi ir veidi, kā nodrošināt pavedienu drošību iOS lietojumprogrammās?

iOS drošības nodrošināšanai izmanto šādus galvenos mehānismus:

1. Mutex (mūtuoks):

   • pthread_mutex_t: zema līmeņa C API no POSIX:
   • NSLock: objektorientēts bloķēšanas mehānisms, Foundation daļa:
   • NSRecursiveLock: ļauj rekursīvu bloķēšanu tajā pašā pavedienā:

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

2. Spin Lock:

   • OSSpinLock: novecojis un nav ieteicams, jo ir problēmas ar prioritāšu pārvaldību un pārmērīgu CPU patēriņu ilgstošas gaidīšanas laikā:
   • os_unfair_lock: efektīvāka alternatīva, OSSpinLock daļa, os.xnu:

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

3. Semaphore (semafor):

   • DispatchSemaphore: Grand Central Dispatch semafors, resursu piekļuves pārvaldībai pēc skaitītāja:

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Skaitītājs = 1 (līdzīgs mūtuokim)
   var limitedResource = 0
   
   func accessLimitedResource() {
       semaphore.wait() // samazina skaitītāju, bloķē ja <= 0
       // Kritiskā sekcija
       limitedResource += 1
       semaphore.signal() // palielina skaitītāju
   }
   

4. Konkurējoša rinda ar barjeras uzdevumiem:

   • izmanto konkurējošu rindu (concurrent queue) GCD, lasīšanai un rakstīšanai:

   import Foundation
   
   let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)
   var protectedArray: [Int] = []
   
   func addItem(_ item: Int) {
       concurrentQueue.sync(flags: .barrier) {
           // uzdevums ar .barrier zīmi tiek izpildīts ekskluzīvi
           protectedArray.append(item)
       }
   }
   
   func readArray() -> [Int] {
       var arrayCopy: [Int] = []
       concurrentQueue.sync {
           // parasta sinhronizēta uzdevuma (lasīšana) var būt paralēla ar citām lasīšanām
           arrayCopy = protectedArray
       }
       return arrayCopy
   }
   

5. Atomāras operācijas:

   • zema līmeņa operācijas, kas garantē atomarību (izpildās kā vienots veselums, bez pārtraukumiem):

   import Darwin // dažas atomāras funkcijas, piemēram, OSAtomic...
   
   var atomicCounter: Int32 = 0
   
   func incrementAtomicCounter() -> Int32 {
       // piemērs atomārai operācijai
       return OSAtomicIncrement32(&atomicCounter)
   }
   

   • Swift ir eksperimentālas Atomic<Value> tipus swift-atomics bibliotēkā:

6. Gaismas sanitizators:

   • rīks, kas atklāj datu sacensības (data races) izpildes laikā:

Mehānisma izvēle ir atkarīga no uzdevuma:

• Vienkārša ekskluzīva piekļuve: NSLock, DispatchSemaphore(value: 1), os_unfair_lock:
• Rekursīva bloķēšana: NSRecursiveLock:
• Lasīšana/rakstīšana: konkurējoša rinda ar .barrier:
• Piekļuves ierobežojums (resursu pulkā): DispatchSemaphore (skaitītājs > 1):
• Vienkārši skaitītāji/karogi: atomāras operācijas (ja piemērojams un nepieciešams maksimālais veiktspējas līmenis):

No tā būtu jāizvairās:

• OSSpinLock:
• Globālo bloķējumu izmantošana bez nepieciešamības:
• Agrīna optimizācija ar zema līmeņa primitives, nesaprotot to darbību.