რა უკეთესია გამოყენება: NSOperationQueue თუ GCD?

არჩევა NSOperationQueue და GCD შორის დამოკიდებულია კონკრეტული დავალების მოთხოვნებზე:

GCD (Grand Central Dispatch) - დაბალ დონეზე C API პარალელური პროგრამირებისათვის, დაფუძნებული რიგების კონცეფციაზე:

NSOperationQueue - მაღალ დონეზე Objective-C/Swift API, შექმნილია GCD-ის ზედა. ის უზრუნველყოფს დამატებით შესაძლებლობებს:

ძირითადი განსხვავებები:

მახასიათებელი	GCD	NSOperationQueue
API დონე	დაბალი დონე	მაღალი დონე
დავალების ტიპი	კოდის ბლოკები (closures Swift-ში)	Operation ობიექტები
დამოკიდებულებები	არ აქვს ინტერნალური მხარდაჭერა	მხარდაჭერა დამოკიდებულებების შორის ოპერაციების
პრიორიტეტი	მხარდაჭერა	მხარდაჭერა, შესაძლებელია შეცვლა
დავალების გაუქმება	რთული რეალიზაცია	მარტივი cancel()-ით რეალიზება
მონიტორინგი	არ აქვს ინტერნალური მხარდაჭერა	აქვს თვისებები მონიტორინგისთვის (isExecuting, isFinished)
მაქსიმალური პარალელური დავალებების რაოდენობა	პირდაპირი კონტროლი არ არის	შესაძლებელია maxConcurrentOperationCount დაყენება
მემკვიდრეობა	არ გამოიყენება ბლოკებზე	შესაძლებელია მემკვიდრეობა მომხმარებლის ოპერაციების შექმნისთვის

როდის გამოიყენოთ:

• როდესაც საჭიროა მაქსიმალური შესრულება და მინიმალური ხარჯები:
• მარტივი ფონური დავალებებისთვის, რომლებიც არ მოითხოვს რთულ ლოგიკას ან დამოკიდებულებებს:
• როდესაც მუშაობთ დაბალ დონეზე API-ებთან:

მაგალითი — მოკლე CPU-კავშირიანი დავალების შესრულება ფონზე:

// DispatchQueue.global(qos: .userInitiated) - საერთო რიგი გარკვეული პრიორიტეტით.
// async - ასინქრონული შესრულება:
DispatchQueue.global(qos: .userInitiated).async {
    // რესურსის ხარჯიანი დავალების შესრულება
    let result = self.performExpensiveCalculation()

    // UI განახლებისთვის გადართვა მთავარ რიგზე
    DispatchQueue.main.async {
        self.updateUI(with: result)
    }
}

როდის გამოიყენოთ NSOperationQueue:

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

მაგალითი დამოკიდებულებით:

import Foundation

// მონაცემების ჩამოტვირთვის ოპერაცია
let downloadOperation = BlockOperation {
    print("მონაცემების ჩამოტვირთვა...")
    Thread.sleep(forTimeInterval: 2) // დაგვიანების იმიტაცია
    print("მონაცემები ჩამოტვირთულია.")
}

// მონაცემების დამუშავების ოპერაცია, დამოკიდებულია ჩამოტვირთვაზე
let processOperation = BlockOperation {
    print("მონაცემების დამუშავება...")
    Thread.sleep(forTimeInterval: 1) // დაგვიანების იმიტაცია
    print("მონაცემები დამუშავებულია.")
}

// დამოკიდებულების დამატება: processOperation ელოდება downloadOperation-ის დასრულებას
processOperation.addDependency(downloadOperation)

// ოპერაციების რიგის შექმნა
let operationQueue = OperationQueue()

// ოპერაციების დამატება რიგში
operationQueue.addOperation(downloadOperation)
operationQueue.addOperation(processOperation)

// ყველა ოპერაციის დასრულების მოლოდინი (დამატებითი, რეალურ აპლიკაციაში ჩვეულებრივ არ გამოიყენება)
operationQueue.waitUntilAllOperationsAreFinished()
print("ყველა ოპერაცია დასრულდა.")

სასურველი:

• მარტივი, დამოუკიდებელი დავალებებისთვის და მაქსიმალური შესრულებისთვის ხშირად ირჩევენ GCD-ს.
• უფრო რთული სცენარებისთვის, დამოკიდებულებებით, გაუქმებით და მონიტორინგით, უკეთესია NSOperationQueue.

NSOperationQueue დამატებით აბსტრაქციას და ფუნქციონალობას აძლევს GCD-ის ზედა, რაც ზოგიერთ დავალებას უფრო მოსახერხებელს ხდის, მაგრამ მცირე დამატებითი ხარჯებით. უმეტეს შემთხვევებში, თუ მისი დამატებითი შესაძლებლობები საჭიროა, NSOperationQueue კარგი არჩევანია.