Ի՞նչ է ավելի լավ օգտագործել՝ NSOperationQueue կամ GCD?

ընտրությունը NSOperationQueue և GCD միջև կախված է կոնկրետ առաջադրանքի պահանջներից:

GCD (Grand Central Dispatch) - ցածր մակարդակի C API հոսքային ծրագրավորման համար, հիմնված հերթերի կոնցեպտի վրա:

NSOperationQueue - բարձր մակարդակի Objective-C/Swift API, կառուցված GCD-ի վրա: Այն առաջարկում է լրացուցիչ հնարավորություններ:

Հիմնական տարբերությունները:

Գծանշում	GCD	NSOperationQueue
API մակարդակ	Նվազագույն մակարդակ	Բարձր մակարդակ
Առաջադրանքի տեսակ	Կոդի բլոկներ (closures Swift-ում)	Operation օբյեկտներ
Dependencies	Չունի ներքին աջակցություն	Աջակցում է կախվածություններին օպերացիաների միջև
Առաջնահերթություն	Աջակցում է	Աջակցում է, հնարավոր է փոփոխել
Առաջադրանքի չեղարկում	Կարծես թե դժվար է իրականացնել	Հեշտ է իրականացնել cancel()-ով
Մոնիտորինգ	Չունի ներքին աջակցություն	Ունեցում է հատկություններ մոնիտորինգի համար (isExecuting, isFinished)
Մաքսիմալ համաժամանակյա առաջադրանքների քանակ	Անհրաժեշտ է հատուկ վերահսկում	Կարող եք սահմանել maxConcurrentOperationCount
ժառանգականություն	Չի կիրառվում բլոկների վրա	Կարող եք ժառանգել՝ ստեղծելու հատուկ օպերացիաներ

Երբ օգտագործել GCD:

• Երբ անհրաժեշտ է առավելագույն արտադրողականություն և նվազագույն ծախսեր:
• Պարզ ֆոնային առաջադրանքների համար, որոնք չեն պահանջում բարդ լոգիկա կամ կախվածություններ:
• Երբ աշխատում եք ցածր մակարդակի 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-ը լավ ընտրություն է։