Ce metode există pentru a asigura securitatea thread-urilor în aplicațiile iOS?

Pentru a asigura siguranța în flux în iOS, se utilizează următoarele mecanisme principale:

1. Mutex (mutual exclusion):

   • pthread_mutex_t: API de nivel inferior din POSIX.
   • NSLock: Înveliș orientat pe obiect peste primitivele de blocare, parte din Foundation.
   • NSRecursiveLock: Permite blocarea recursivă de către același fir.

   import Foundation
   
   let lock = NSLock()
   var sharedResource = 0
   
   func modifySharedResource() {
       lock.lock()
       // Secțiunea critică
       sharedResource += 1
       lock.unlock()
   }
   

2. Spin Lock:

   • OSSpinLock: Învechit și nerecomandat din cauza problemelor cu prioritățile și consumului excesiv de CPU în așteptare prelungită. Înlocuit cu os_unfair_lock.
   • os_unfair_lock: Înlocuire mai eficientă pentru OSSpinLock, parte din os.xnu.

   import os.lock
   
   var unfairLock = os_unfair_lock()
   var anotherResource = 0
   
   func updateResource() {
       os_unfair_lock_lock(&unfairLock)
       // Secțiunea critică
       anotherResource += 1
       os_unfair_lock_unlock(&unfairLock)
   }
   

3. Semaphore (semnal):

   • DispatchSemaphore: Semnal din Grand Central Dispatch (GCD). Controlează accesul la resursă după un contor.

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Contor = 1 (similar cu mutex)
   var limitedResource = 0
   
   func accessLimitedResource() {
       semaphore.wait() // Scade contorul, blochează dacă <= 0
       // Secțiunea critică
       limitedResource += 1
       semaphore.signal() // Crește contorul
   }
   

4. Coada concurentă cu task-uri Barrier:

   • Utilizarea unei cozi concurente în GCD pentru citire și scriere. Citirea se face în paralel (async), scrierea - exclusiv (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) {
           // Task cu flag-ul .barrier executat exclusiv
           protectedArray.append(item)
       }
   }
   
   func readArray() -> [Int] {
       var arrayCopy: [Int] = []
       concurrentQueue.sync {
           // Task sincron normal (citire) poate fi paralelă cu alte citiri
           arrayCopy = protectedArray
       }
       return arrayCopy
   }
   

5. Operații atomice:

   • Operații de nivel jos, garantând atomicitatea (executate ca un întreg, fără întreruperi). Folosite pentru tipuri simple de date ( întregi, pointeri).

   import Darwin // Pentru unele funcții atomice, precum OSAtomic...
   
   var atomicCounter: Int32 = 0
   
   func incrementAtomicCounter() -> Int32 {
       // Exemplu de operație atomică
       return OSAtomicIncrement32(&atomicCounter)
   }
   

   • În Swift există tipuri experimentale Atomic<Value> în swift-atomics.

6. Thread Sanitizer:

   • Instrument de depanare care detectează curse de date (data races) în timpul execuției aplicației. Se activează în schema de build Xcode (Edit Scheme -> Run -> Diagnostics -> Thread Sanitizer).

Alegerea mecanismului depinde de sarcină:

• Acces exclusiv simplu: NSLock, DispatchSemaphore(value: 1), os_unfair_lock.
• Blocare recursivă: NSRecursiveLock.
• Citire/scriere: Coadă concurentă cu .barrier.
• Restricție acces (pool de resurse): DispatchSemaphore (cu contor > 1).
• Contorizare/flaguri simple: Operații atomice (dacă se aplică și necesită performanță maximă, cu precauție).

Evită:

• OSSpinLock.
• Utilizarea blocărilor globale fără nevoie.
• Optimizarea prematură cu primitive de nivel jos fără înțelegerea modului lor de funcționare.