Ի՞նչ եղանակներ կան iOS հավելվածներում թելերի անվտանգությունը ապահովելու համար։

iOS-ում հոսքերի անվտանգությունը ապահովելու համար օգտագործվում են հետևյալ հիմնական մեխանիզմները:

1. Mutex (մյուտեքս):

   • pthread_mutex_t: Ներքևի մակարդակի C API՝ POSIX-ից:
   • NSLock: Օբյեկտային օղակվածություն՝ բլոկավորման պրիմիտիվների վրա, Foundation-ի մաս:
   • NSRecursiveLock: Թույլ է տալիս ռեկուրսիվ բլոկավորում՝ նույն հոսքից:

   import Foundation
   
   let lock = NSLock()
   var sharedResource = 0
   
   func modifySharedResource() {
       lock.lock()
       // Կրիտիկական հատված
       sharedResource += 1
       lock.unlock()
   }
   

2. Spin Lock:

   • OSSpinLock: Հնացած և խորհուրդ չի տրվում՝ առաջնահերթությունների խնդիրների և CPU-ի ավելորդ սպառման պատճառով՝ երկար սպասման ժամանակ:
   • os_unfair_lock: Ավելի արդյունավետ փոխարինող՝ OSSpinLock-ին, os.xnu-ի մաս:

   import os.lock
   
   var unfairLock = os_unfair_lock()
   var anotherResource = 0
   
   func updateResource() {
       os_unfair_lock_lock(&unfairLock)
       // Կրիտիկական հատված
       anotherResource += 1
       os_unfair_lock_unlock(&unfairLock)
   }
   

3. Semaphore (սեմաֆոր):

   • DispatchSemaphore: Grand Central Dispatch-ից սեմաֆոր՝ ռեսուրսի մուտքի կառավարման համար:

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Սխեմայի հաշվիչը՝ 1 (մյուտեքսի նման)
   var limitedResource = 0
   
   func accessLimitedResource() {
       semaphore.wait() // Հանում է հաշվիչը, բլոկավորում է եթե <= 0
       // Կրիտիկական հատված
       limitedResource += 1
       semaphore.signal() // Ավելացնում է հաշվիչը
   }
   

4. Համաժամանակյա հերթ (Concurrent Queue)՝ Barrier Tasks-ով:

   • Օգտագործում է համաժամանակյա հերթ՝ GCD-ում՝ ընթերցանության և գրառման համար:

   import Foundation
   
   let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)
   var protectedArray: [Int] = []
   
   func addItem(_ item: Int) {
       concurrentQueue.sync(flags: .barrier) {
           // Բարերի նշանով գործառույթը կատարվում է միայնակ
           protectedArray.append(item)
       }
   }
   
   func readArray() -> [Int] {
       var arrayCopy: [Int] = []
       concurrentQueue.sync {
           // Ընթերցումը կարող է կատարվել միաժամանակ այլ ընթերցումների հետ
           arrayCopy = protectedArray
       }
       return arrayCopy
   }
   

5. Ատոմարային օպերացիաներ:

   • Ներքևի մակարդակի օպերացիաներ՝ ապահովելով ատոմարություն՝ միաժամանակյա կատարման ժամանակ:

   import Darwin // Որոշ ատոմարային ֆունկցիաների համար՝ օրինակ OSAtomic...
   
   var atomicCounter: Int32 = 0
   
   func incrementAtomicCounter() -> Int32 {
       // Օրինակ՝ ատոմարային օպերացիա
       return OSAtomicIncrement32(&atomicCounter)
   }
   

   • Swift-ում կա փորձնական Atomic<Value> տիպ՝ swift-atomics գրադարանում:

6. Thread Sanitizer:

   • Դիտարկման գործիք՝ տվյալների մրցակցությունները հայտնաբերելու համար՝ ռնգեղջյուրի ժամանակ:

Մեխանիզմի ընտրությունը կախված է խնդիրից:

• Պարզ բացառիկ մուտք: NSLock, DispatchSemaphore(value: 1), os_unfair_lock:
• Ռեկուրսիվ բլոկավորում: NSRecursiveLock:
• Ընթերցում/գրառում: Համաժամանակյա հերթ՝ .barrier-ով:
• Մուտքի սահմանափակում (ռեսուրսների պուլ): DispatchSemaphore (հաշվիչ > 1):
• Պարզ հաշվիչներ/գլոբալ նշաններ: Ատոմարային օպերացիաներ՝ եթե կիրառելի և պահանջվում է առավելագույն կատարողականություն:

Ավելի լավ է խուսափել:

• OSSpinLock-ից:
• Գլոբալ բլոկավորումների անպատճառ օգտագործումից:
• Նախաժամկետ օպտիմիզացիայից՝ առանց հասկանալու դրանց աշխատանքի մասին։