iOS uygulamalarında iş parçacıklarının güvenliğini sağlamak için hangi yöntemler vardır?

iOS'ta iş parçacığı güvenliğini sağlamak için aşağıdaki temel mekanizmalar kullanılır:

1. Mutex (karşılıklı dışlama):

   • pthread_mutex_t: POSIX'ten düşük seviyeli C API.
   • NSLock: Lock primitive'leri üzerine nesne yönelimli sarmalayıcı, Foundation'ın bir parçası.
   • NSRecursiveLock: Aynı iş parçacığı tarafından yinelenen kilitlenmeye izin verir.

   import Foundation
   
   let lock = NSLock()
   var paylaşılanKaynak = 0
   
   func paylaşılanKaynağıDeğiştir() {
       lock.lock()
       // Kritik bölüm
       paylaşılanKaynak += 1
       lock.unlock()
   }
   

2. Spin Lock:

   • OSSpinLock: eski ve önermeyen, öncelik sorunları ve uzun beklemede CPU tüketimi nedeniyle. os_unfair_lock ile değiştirilmiştir.
   • os_unfair_lock: OSSpinLock'in daha verimli alternatifi, os.xnu'nun bir parçası.

   import os.lock
   
   var unfairLock = os_unfair_lock()
   var başkaBirKaynak = 0
   
   func kaynağıGüncelle() {
       os_unfair_lock_lock(&unfairLock)
       // Kritik bölüm
       başkaBirKaynak += 1
       os_unfair_lock_unlock(&unfairLock)
   }
   

3. Semafor:

   • DispatchSemaphore: Grand Central Dispatch (GCD) semaforu. Bir sayıcı aracılığıyla kaynağa erişimi kontrol eder.

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Sayıcı = 1 (mutex'e eşdeğer)
   var sınırlıKaynak = 0
   
   func sınırlıKaynağaErişim() {
       semaphore.wait() // Sayacı azaltır, 0 veya daha azsa bloklar
       // Kritik bölüm
       sınırlıKaynak += 1
       semaphore.signal() // Sayacı artırır
   }
   

4. Eşzamanlı Kuyruk ve Barrier Görevleri:

   • GCD'de eşzamanlı kuyruk kullanımı (concurrent queue) okuma ve yazma için. Okuma paralel (async), yazma ise münhasır (sync(flags: .barrier)).

   import Foundation
   
   let eşzamanlıKuyruk = DispatchQueue(label: "com.ornek.eşzamanlıKuyruk", attributes: .concurrent)
   var korumalıDizi: [Int] = []
   
   func öğeEkle(_ öğe: Int) {
       eşzamanlıKuyruk.sync(flags: .barrier) {
           // .barrier bayrağı ile görev, münhasır olarak çalışır
           korumalıDizi.append(öğe)
       }
   }
   
   func diziyiOku() -> [Int] {
       var diziKopyası: [Int] = []
       eşzamanlıKuyruk.sync {
           // Normal senkron görev (okuma), diğer okumalara paralel olabilir
           diziKopyası = korumalıDizi
       }
       return diziKopyası
   }
   

5. Atomik İşlemler:

   • Düşük seviyeli işlemler, atomiklik garantisi sağlar (tek parça olarak, kesintisiz çalışır). Basit veri tipleri (tam sayılar, işaretçiler) için kullanılır.

   import Darwin // Bazı atomik fonksiyonlar için, örneğin OSAtomic...
   
   var atomikSayaç: Int32 = 0
   
   func atomikSayaçArtır() -> Int32 {
       // Atomik işlem örneği
       return OSAtomicIncrement32(&atomikSayaç)
   }
   

   • Swift'te Atomic<Value> gibi deneme amaçlı tipler swift-atomics içinde mevcuttur.

6. İş Parçacığı Temizleyicisi (Thread Sanitizer):

   • Uygulama çalışırken veri yarışlarını tespit eden hata ayıklama aracı. Xcode derleme şemasında etkinleştirilir (Edit Scheme -> Run -> Diagnostics -> Thread Sanitizer).

Mekanizmanın seçimi göreve bağlıdır:

• Basit münhasır erişim: NSLock, DispatchSemaphore(value: 1), os_unfair_lock.
• Yinelenen kilit: NSRecursiveLock.
• Okuma/yazma: .barrier ile eşzamanlı kuyruk.
• Erişim kısıtlaması (kaynak havuzu): DispatchSemaphore (sayacı > 1 ile).
• Basit sayaçlar/ bayraklar: Atomik işlemler (uygunsa ve maksimum performans gerekiyorsa, dikkatli olunmalı).

Kaçınılması gerekenler:

• OSSpinLock.
• Gereksiz küresel kilitlerin kullanımı.
• Düşük seviyeli primitive'lerle erken optimizasyon, bunların nasıl çalıştığını anlamadan.