რას ემყარება ბარიერები და სემაფორები?

პარალელური პროგრამირების კონტექსტში ბარიერები და სემაფორები სინქრონიზაციის მექანიზმებზეა დაფუძნებული:

• სემაფორები: ეფუძნება ანტომურ ოპერაციებს გამოთვლაზე. ძირითადი ოპერაციები:

  • wait (ან P, acquire): ამცირებს გამოთვლას. თუ გამოთვლა უარყოფითია, ნაკადი ბლოკდება, სანამ სხვა ნაკადი არ შეასრულებს signal-ს.
  • signal (ან V, release): ზრდის გამოთვლას. თუ ბლოკირებული ნაკადები არსებობს, ერთ-ერთი მათგანი იღვიძებს.
  • სემაფორები შეიძლება იყოს ბინარული (მნიშვნელობა 0 ან 1, როგორც მუტექსები) ან გამოთვლითი (მიზეზად შეზღუდული რაოდენობის ნაკადებს რესურსზე წვდომა).

• ბარიერები (Barriers): ეფუძნება ყველა მონაწილესთან მოლოდინის მექანიზმს. ნაკადი, რომელიც აღწევს ბარიერს, ბლოკდება, სანამ ყველა სხვა მონაწილე, რომელიც სინქრონიზაციაში მონაწილეობს, ასევე არ მიაღწევს ამ ბარიერს. ყველა მიაღწევს, ისინი ერთდროულად განაგრძობენ მუშაობას.

ამ კონცეფციები რეალიზებულია iOS/macOS პროგრამირებაში GCD (Grand Central Dispatch) და OperationQueue ფრეიმვორკების გამოყენებით:

მაგალითად, GCD-ში:

// DispatchSemaphore-ის გამოყენების მაგალითი
let semaphore = DispatchSemaphore(value: 1) // ბინარული სემაფორი

// მოლოდინი (acquire)
semaphore.wait()
// კრიტიკული სექციის შესრულება
semaphore.signal() // სიგნალი (release)

GCD-ის ბარიერები რეალიზებულია ბარიერული დავალებების (barrier tasks) საშუალებით ერთობლივ რიგებში:

let concurrentQueue = DispatchQueue(label: "com.example.concurrentQueue", attributes: .concurrent)

// ჩვეულებრივი დავალებები
concurrentQueue.async {
    // ...
}

// ბარიერული დავალება - შესრულდება მხოლოდ როდესაც ყველა წინამორბედი ჩვეულებრივი დავალება დასრულდება
// და ამის შემდეგ ახალი დავალებები არ დაიწყება სანამ ეს დასრულდება
concurrentQueue.async(flags: .barrier) {
    // ...
}

// ჩვეულებრივი დავალებები, რომლებიც დაიწყება ბარიერული დასრულების შემდეგ
concurrentQueue.async {
    // ...
}