Koji su načini za obezbeđivanje bezbednosti niti u iOS aplikacijama?

Za obezbeđivanje bezbednosti niti u iOS koriste se sledeći osnovni mehanizmi:

1. Mutex (međusobno isključivanje):

   • pthread_mutex_t: Niskonivou API iz POSIX-a.
   • NSLock: Objektno-orijentisana omotač preko primitiveskih zaključavanja, deo Foundation-a.
   • NSRecursiveLock: Dozvoljava rekurzivno zaključavanje istom nitju.

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

2. Spin Lock:

   • OSSpinLock: Zastareo i nedoporučen zbog problema sa prioritetima i prekomernog korišćenja CPU-a pri dužem čekanju. Zamenjen sa os_unfair_lock.
   • os_unfair_lock: Efikasnija zamena za OSSpinLock, deo os.xnu.

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

3. Semaphore (semafor):

   • DispatchSemaphore: Semafor iz Grand Central Dispatch (GCD). Kontroliše pristup resursu pomoću brojača.

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Brojač = 1 (slično mutexu)
   var limitedResource = 0
   
   func accessLimitedResource() {
       semaphore.wait() // Smanjuje brojač, blokira ako je <= 0
       // Kritična sekcija
       limitedResource += 1
       semaphore.signal() // Povećava brojač
   }
   

4. Konkurenčka red sa Barrier zadacima:

   • Korišćenje konkurentne red (concurrent queue) u GCD za čitanje i pisanje. Čitanje se vrši paralelno (async), pisanje - isključivo (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) {
           // Zadatak sa oznakom .barrier se izvršava isključivo
           protectedArray.append(item)
       }
   }
   
   func readArray() -> [Int] {
       var arrayCopy: [Int] = []
       concurrentQueue.sync {
           // Običan sinhroni zadatak (čitanje) može biti paralelan sa drugim čitanjima
           arrayCopy = protectedArray
       }
       return arrayCopy
   }
   

5. Atomske operacije:

   • Niskonivou operacije koje garantuju atomarnost (izvršavaju se kao celina, bez prekida). Koriste se za jednostavne tipove podataka (celobrojne, pokazivače).

   import Darwin // Za neke atomske funkcije, na primer OSAtomic...
   
   var atomicCounter: Int32 = 0
   
   func incrementAtomicCounter() -> Int32 {
       // Primer atomske operacije
       return OSAtomicIncrement32(&atomicCounter)
   }
   

   • U Swift-u postoje eksperimentalni tipovi Atomic<Value> u swift-atomics.

6. Thread Sanitizer:

   • Alat za otklanjanje grešaka koji otkriva trke podataka (data races) tokom izvršavanja aplikacije. Uključuje se u šemu za izgradnju Xcode-a (Edit Scheme -> Run -> Diagnostics -> Thread Sanitizer).

Izbor mehanizma zavisi od zadatka:

• Jednostavan ekskluzivni pristup: NSLock, DispatchSemaphore(value: 1), os_unfair_lock.
• Rekurzivno zaključavanje: NSRecursiveLock.
• Čitanje/zapis: Konkurenčka red sa .barrier.
• Ograničenje pristupa (bazeni resursa): DispatchSemaphore (sa brojačem > 1).
• Jednostavni brojači/flags: Atomicke operacije (ako su primenjive i zahtevaju maksimalnu performansu, sa oprezom).

Izbegavajte:

• OSSpinLock.
• Korišćenje globalnih zaključavanja bez potrebe.
• Preuranjenu optimizaciju pomoću primitives niskog nivoa bez razumevanja njihovog rada.