iOS tətbiqlərində iş parçalarının təhlükəsizliyini təmin etmək üçün hansı üsullar mövcuddur?

iOS-da çoxluq təhlükəsizliyini təmin etmək üçün aşağıdakı əsas mexanizmlər istifadə olunur:

1. Mutex (mutual exclusion):

   • pthread_mutex_t: POSIX-in aşağı səviyyəli API-si.
   • NSLock: Bloklama primitive üzərində obyekt yönümlü örtük, Foundation-in bir hissəsidir.
   • NSRecursiveLock: Eyni axın tərəfindən rekursiv bloklama imkanı verir.

   import Foundation
   
   let lock = NSLock()
   var sharedResource = 0
   
   func modifySharedResource() {
       lock.lock()
       // Kritik bölmə
       sharedResource += 1
       lock.unlock()
   }
   

2. Spin Lock:

   • OSSpinLock: Köhnəlib və prioritet problemləri və uzun müddət gözləmə zamanı CPU istifadəsinin çoxluğu səbəbindən tövsiyə edilmir. os_unfair_lock ilə əvəz olunub.
   • os_unfair_lock: OSSpinLock-in daha effektiv əvəzi, os.xnu-nun bir hissəsidir.

   import os.lock
   
   var unfairLock = os_unfair_lock()
   var anotherResource = 0
   
   func updateResource() {
       os_unfair_lock_lock(&unfairLock)
       // Kritik bölmə
       anotherResource += 1
       os_unfair_lock_unlock(&unfairLock)
   }
   

3. Semaphore (semafor):

   • DispatchSemaphore: Grand Central Dispatch (GCD)-dən semafor. Resursa girişə sayğac ilə nəzarət edir.

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Sayğac = 1 (mutuqa bənzər)
   var limitedResource = 0
   
   func accessLimitedResource() {
       semaphore.wait() // Sayğacı azaldır, 0-dan kiçik olarsa bloklayır
       // Kritik bölmə
       limitedResource += 1
       semaphore.signal() // Sayğacı artırır
   }
   

4. Concurrency Queue ilə Barrier Tasks:

   • GCD-də konkurrent kuyrukdan istifadə edərək oxuma və yazma. Oxuma paralel şəkildə (async), yazma isə eksklüziv (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) {
           // .barrier bayrağı ilə tapşırıq eksklüziv yerinə yetirilir
           protectedArray.append(item)
       }
   }
   
   func readArray() -> [Int] {
       var arrayCopy: [Int] = []
       concurrentQueue.sync {
           // Adi sinxron tapşırıq (oxuma) digər oxumalarla paralel ola bilər
           arrayCopy = protectedArray
       }
       return arrayCopy
   }
   

5. Atomik əməliyyatlar:

   • Aşağı səviyyəli əməliyyatlar, atomikliyi təmin edir (birlikdə, fasiləsiz yerinə yetirilir). Sadə tipli məlumatlar üçün istifadə olunur (tam ədədlər, göstəricilər).

   import Darwin // Bəzi atomik funksiyalar üçün, məsələn OSAtomic...
   
   var atomicCounter: Int32 = 0
   
   func incrementAtomicCounter() -> Int32 {
       // Atomik əməliyyat nümunəsi
       return OSAtomicIncrement32(&atomicCounter)
   }
   

   • Swift-də Atomic<Value> kimi eksperimental tiplər mövcuddur swift-atomics-də.

6. Thread Sanitizer:

   • İş vaxtı yarışlarını (data races) aşkar edən debugging aləti. Xcode-un quruluş sxemində aktivləşdirilir (Edit Scheme -> Run -> Diagnostics -> Thread Sanitizer).

Mekanizmin seçimi vəzifədən asılıdır:

• Sadə eksklüziv giriş: NSLock, DispatchSemaphore(value: 1), os_unfair_lock.
• Rekursiv kilidləmə: NSRecursiveLock.
• Oxuma/yazma: .barrier ilə konkurrent queue.
• Giriş məhdudlaşdırması (resurs hovuzu): DispatchSemaphore (sayğacı > 1 ilə).
• Sadə sayğaclar/ bayraqlar: Atomik əməliyyatlar (əgər tətbiq olunursa və maksimum performans tələb olunursa, ehtiyatla).

Təhlükəsizliyi təmin etmək üçün:

• OSSpinLock-dən qaçın.
• Gərək olmadan qlobal bloklamalardan istifadə etməyin.
• Aşağı səviyyəli primitive-lərlə optimizasiyadan əvvəl onların iş prinsipini yaxşı anlayın.