Milyen módszerek léteznek az iOS alkalmazások szálbiztonságának biztosítására?

Az iOS-ben a szálbiztonság biztosításához a következő fő mechanizmusokat használják:

1. Mutex (kölcsönös kizárás):

   • pthread_mutex_t: Alacsony szintű API a POSIX-től.
   • NSLock: Objektumorientált burkolat a primitív zárolások felett, a Foundation része.
   • NSRecursiveLock: Lehetővé teszi az ugyanazon szál által történő rekurzív zárolást.

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

2. Spin Lock:

   • OSSpinLock: Elavult és nem ajánlott a prioritások problémái és a CPU túlzott fogyasztása miatt hosszú várakozás esetén. A os_unfair_lock-ra cserélték.
   • os_unfair_lock: Hatékonyabb helyettesítő az OSSpinLock-hoz, az os.xnu része.

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

3. Semaphore (szemafor):

   • DispatchSemaphore: A Grand Central Dispatch (GCD) szemafora. A hozzáférést egy számlálóval szabályozza.

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Számláló = 1 (hasonló a mutexhoz)
   var limitedResource = 0
   
   func accessLimitedResource() {
       semaphore.wait() // Csökkenti a számlálót, blokkol, ha <= 0
       // Kritikus szekció
       limitedResource += 1
       semaphore.signal() // Növeli a számlálót
   }
   

4. Párhuzamos sor Barrier feladatokkal:

   • A GCD-ben párhuzamos sor (concurrent queue) használata olvasáshoz és íráshoz. Az olvasás párhuzamosan történik (async), az írás kizárólagos (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) {
           // A .barrier zászlóval ellátott feladat kizárólagosan hajtódik végre
           protectedArray.append(item)
       }
   }
   
   func readArray() -> [Int] {
       var arrayCopy: [Int] = []
       concurrentQueue.sync {
           // Normál szinkron feladat (olvasás) párhuzamos lehet más olvasásokkal
           arrayCopy = protectedArray
       }
       return arrayCopy
   }
   

5. Atomi műveletek:

   • Alacsony szintű műveletek, amelyek garantálják az atomosságot (egyben, megszakítás nélkül végrehajtva). Egyszerű típusokra (egész számok, mutatók) használják.

   import Darwin // Néhány atomikus funkcióhoz, például OSAtomic...
   
   var atomicCounter: Int32 = 0
   
   func incrementAtomicCounter() -> Int32 {
       // Példa atomikus műveletre
       return OSAtomicIncrement32(&atomicCounter)
   }
   

   • Swiftben kísérleti típusok léteznek Atomic<Value> néven a swift-atomics csomagban.

6. Szálbiztosító szanitizer:

   • Hibakereső eszköz, amely észleli az adatszivárgásokat (data races) az alkalmazás futása közben. Beállítható az Xcode build konfigurációban (Edit Scheme -> Run -> Diagnostics -> Thread Sanitizer).

A mechanizmus kiválasztása a feladattól függ:

• Egyszerű kizárólagos hozzáférés: NSLock, DispatchSemaphore(value: 1), os_unfair_lock.
• Rekurzív zárolás: NSRecursiveLock.
• Olvasás/írás: Párhuzamos sor .barrier-rel.
• Hozzáférés korlátozása (erőforrás medence): DispatchSemaphore (számláló > 1).
• Egyszerű számlálók/ zászlók: Atomikus műveletek (ha alkalmazható és maximális teljesítményt igényel, óvatosan).

Kerülendő:

• OSSpinLock.
• Globális zárolások használata szükségtelen esetekben.
• Korai optimalizálás alacsony szintű primitívekkel anélkül, hogy megértenénk azok működését.