OperationQueue — ano ito, Operation at pamamahala ng gawain

Ano ang OperationQueue at Operation

OperationQueue ay isang klase mula sa Foundation framework na namamahala sa execution ng mga object ng Operation. Hindi tulad ng DispatchQueue, ang OperationQueue ay hindi nangangailangan ng eksplisitong pagtukoy ng serial o concurrent mode — ang bilang ng sabay-sabay na isinasagawang operasyon ay inaayos ng property na maxConcurrentOperationCount. Ang halagang 1 ay ginagawang sequential ang pila, anumang iba pang halaga ay ginagawa itong concurrent.

Operation ay isang abstract na klase na kumakatawan sa isang unit ng trabaho. Ang bawat operasyon ay may estado: ready, executing, finished, o cancelled. Ang mga estado ay compatible sa KVO (Key-Value Observing), na nagpapahintulot ng reaksyon sa mga pagbabago — halimbawa, pag-update ng UI kapag natapos ang isang operasyon. Ang Operation ay awtomatikong namamahala ng mga flag na isExecuting at isFinished.

Ayon sa Apple (2026), ang OperationQueue ay gumagamit ng GCD sa ilalim nito, ngunit nagdaragdag ng functionality na hindi available sa DispatchQueue: mga dependency, mga prayoridad, at pagkansela ng mga operasyon. Kung ang app ay pumunta sa background mode, ang OperationQueue ay nagpa-pause ng execution, at sa pagbalik — ito ay nagpapatuloy. Ang OperationQueue ay awtomatikong isinasaalang-alang ang bilang ng mga core ng processor at pinipili ang optimal na bilang ng mga thread.

Lifecycle ng Operation

Ang bawat operasyon ay dumadaan sa apat na estado: pending (naghihintay), ready (handa nang magsimula), executing (isinasagawa), at finished (natapos). Ang estado na cancelled ay maaaring mangyari sa anumang yugto bago matapos. Ang mga paglipat sa pagitan ng mga estado ay sinusubaybayan sa pamamagitan ng KVO — ito ang batayan para sa reaktibong pag-update ng UI. Ang OperationQueue ay awtomatikong nag-aalis ng mga natapos na operasyon mula sa pila at nag-aabiso sa mga dependent na operasyon na ang kanilang precondition ay natupad na, sinisimulan ang kanilang execution.

Operation at BlockOperation: implementasyon ng mga gawain

Operation ay isang abstract na klase na nangangailangan ng override ng main() o start() method. Sa main() method inilalagay ang code ng gawain, at ang estado na isExecuting at isFinished ay awtomatikong pinamamahalaan. Para sa mga asynchronous na operasyon, kinakailangan ang override ng start() at manu-manong pamamahala ng mga flag ng estado.

BlockOperation ay isang kongkretong implementasyon ng Operation na nagpapatupad ng isa o higit pang mga bloke ng code. Ang BlockOperation ay nagiging concurrent kung maraming bloke ang idaragdag sa pamamagitan ng addExecutionBlock(). Ang operasyon ay matatapos lamang pagkatapos ng execution ng lahat ng idinagdag na bloke. Ang BlockOperation ay isang maginhawang alternatibo para sa mga simpleng gawain na walang inheritance.

Paggawa ng Custom na Operation

Para gumawa ng custom na operasyon, magmana mula sa Operation at i-override ang main(). Sa loob, suriin ang flag na isCancelled bago ang mga mamahaling operasyon upang matiyak ang mabilis na pagkansela. Ito ay kritikal para sa pag-download ng malalaking file o batch processing ng data. Pagpili sa pagitan ng Operation at BlockOperation ay depende sa pagiging kumplikado ng gawain: para sa mga simpleng isang-beses na aksyon, sapat na ang BlockOperation, para sa reusable na lohika na may estado — inheritance mula sa Operation.

Mga dependency at prayoridad ng operasyon

Mga Dependency ay pangunahing bentahe ng OperationQueue kumpara sa DispatchQueue. Ang addDependency(_:) method ay tumutukoy na ang operasyon B ay isinasagawa lamang pagkatapos makumpleto ang operasyon A. Ang mga dependency ay bumubuo ng directed acyclic graph (DAG): kapag may idinagdag na cyclic dependency, hindi ito pinapansin ng pila at ang mga operasyon ay hindi nasisimulan.

Prayoridad ng isang operasyon ay itinakda ng property na queuePriority na may mga halaga: .veryLow, .low, .normal, .high, .veryHigh. Ang prayoridad ay nakakaapekto sa pagkakasunod-sunod ng pagsisimula sa mga ready-operasyon, ngunit hindi nito pinapalitan ang mga dependency. Ang OperationQueue ay unang isinasaalang-alang ang mga dependency, pagkatapos ang prayoridad sa mga available na operasyon.

Praktikal na Halimbawa ng mga Dependency

Karaniwang senaryo — pag-load ng data ng profile: una naming i-load ang user, pagkatapos batay sa kanyang id ay i-load namin ang mga kaibigan at post. Ang pagtatakda ng dependency sa pagitan ng pag-load ng user at pag-load ng mga kaibigan ay ginagarantiyahan ang tamang pagkakasunod-sunod nang walang nested completion handler.

Paglilimita ng Paralelismo

Ang property na maxConcurrentOperationCount ay naglilimita sa bilang ng sabay-sabay na isinasagawang operasyon. Ang halagang 1 ay lumilikha ng sequential na pila, ang default na halaga (NSOperationQueueDefaultMaxConcurrentOperationCount) — optimal sa system, depende sa kasalukuyang load ng device. Ang tamang pagtatakda ng parameter na ito ay pumipigil sa labis na pagkonsumo ng mapagkukunan: para sa pag-load ng mga imahe, sapat na ang 4-6 concurrent na operasyon, para sa CPU-intensive na gawain — bilang ng mga core ng processor.

OperationQueue vs DispatchQueue: paghahambing

Ang pagpili sa pagitan ng OperationQueue at DispatchQueue ay depende sa pagiging kumplikado ng gawain. Ang DispatchQueue ay isang magaan na tool para sa simpleng async na tawag. Ang OperationQueue ay isang mas mabigat na solusyon para sa mga komplikadong senaryo na may maraming magkakaugnay na gawain. Inirerekomenda ng Apple na magsimula sa DispatchQueue at lumipat sa OperationQueue lamang kapag kailangan ang mga dependency o pagkansela. Para sa karamihan ng mga proyekto sa iOS, ang kombinasyon ng parehong tool ay nagbibigay ng optimal na balanse sa pagitan ng performance at flexibility.

• DispatchQueue — magaan, mabilis, walang overhead ng mga object ng Operation
• OperationQueue — sumusuporta sa mga dependency, pagkansela, KVO, at prayoridad
• DispatchQueue — perpekto para sa simpleng async/asyncAfter na gawain at synchronisasyon sa pamamagitan ng serial
• OperationQueue — kailangang-kailangan para sa step-by-step na algorithm na may sunud-sunod na yugto
• DispatchQueue — integrasyon sa Swift Concurrency (async/await) sa pamamagitan ng Continuation

Ayon kay Ray Wenderlich (2025), sa malalaking proyekto sa iOS, ang OperationQueue ay ginagamit para sa pag-load ng nilalaman na may progreso at pagkansela, at ang DispatchQueue para sa lahat ng iba pang async na operasyon. Ang ratio ay humigit-kumulang 20 hanggang 80 pabor sa DispatchQueue.

Mga halimbawa ng code sa OperationQueue sa Swift

Tingnan natin ang tatlong halimbawa: simpleng BlockOperation, custom na Operation na may mga dependency, at isang nakanselang operasyon para sa pag-load ng data.

BlockOperation na may completion

Ang pinakasimpleng kaso — mag-execute ng isang bloke sa OperationQueue at iproseso ang resulta sa pamamagitan ng completionBlock. Ang bawat Operation ay may built-in na property na completionBlock na tinatawag pagkatapos makumpleto ang main().

let queue = OperationQueue()
let operation = BlockOperation()
operation.addExecutionBlock {
    let data = NetworkService.fetchData()
    OperationQueue.main.addOperation {
        self.updateUI(data)
    }
}
queue.addOperation(operation)

Mga dependency sa pagitan ng mga operasyon

Dependency ay ginagarantiyahan na ang parseOperation ay magsisimula lamang pagkatapos makumpleto ang downloadOperation. Tinatanggal nito ang pangangailangan para sa nested callback.

let download = BlockOperation { self.downloadJSON() }
let parse = BlockOperation { self.parseJSON() }
parse.addDependency(download)

let queue = OperationQueue()
queue.addOperations([download, parse], waitUntilFinished: false)

Nakanselang Custom na Operation

I-override ang main() na may periodic na pagsusuri ng isCancelled. Ito ay nagpapahintulot ng agarang paghinto ng operasyon kapag nakansela, nang hindi naghihintay na matapos ang mamahaling operasyon.

class ImageLoadOperation: Operation {
    override func main() {
        guard !self.isCancelled else { return }
        let image = self.downloadImage()
        guard !self.isCancelled else { return }
        OperationQueue.main.addOperation { self.display(image) }
    }
}

Pagkansela ng mga operasyon at pagmamasid sa KVO

Pagkansela ng isang operasyon ay nagtatakda ng flag na isCancelled sa true, ngunit hindi nito pinipigilan ang main() method na nasimulan na. Ang code sa loob ng main() ay dapat na independiyenteng suriin ang isCancelled at magtapos kung kinakailangan. Ito ay isang arkitektural na desisyon ng Apple — na nagpapahintulot sa developer na maayos na maglabas ng mga mapagkukunan sa pagkansela.

Pagmamasid sa KVO sa mga property na isFinished at isExecuting ay nagpapahintulot ng reaksyon sa pagkumpleto ng mga operasyon nang walang eksplisitong callback. Awtomatikong inaalis ng OperationQueue ang mga natapos na operasyon mula sa pila, ngunit nananatili sila sa memorya hangga't mayroong malakas na reference. KVO ay ang batayan para sa integrasyon ng OperationQueue sa mga reaktibong framework tulad ng RxSwift o Combine.

Pamamahala ng pagkansela sa pamamagitan ng KVO

Ang pag-subscribe sa isCancelled sa pamamagitan ng KVO ay nagpapahintulot ng pag-update ng UI sa pagkansela ng isang operasyon — halimbawa, pagpapakita ng placeholder sa halip ng nakanselang download. Ang property na isCancelled ay KVO-compatible, na ginagawang maginhawa para sa reaktibong pipeline.

Mga Pinakamahusay na Kasanayan sa Paggawa gamit ang OperationQueue

Huwag gumawa ng maraming operasyon — bawat Operation ay isang hiwalay na object sa memorya. Kung ang gawain ay maikli at hindi nangangailangan ng mga dependency, gamitin ang DispatchQueue nang direkta. Ang OperationQueue ay makatwiran lamang para sa mga komplikadong senaryo na may eksplisitong dependency, pagkansela, at pagsubaybay sa progreso.

Suriin ang isCancelled bago ang mga mamahaling operasyon sa loob ng main() method. Sa kaso ng pag-download ng mga file o pagproseso ng mga imahe, ang pagsusuri pagkatapos ng bawat makabuluhang hakbang ay nagsisiguro ng mabilis na pagtugon sa pagkansela. Gamitin ang if isCancelled { return } sa simula ng main() at pagkatapos ng bawat malaking operasyon.

Pamahalaan nang tama ang completionBlock. Ang completionBlock property ng isang operasyon ay tinatawag pagkatapos makumpleto ang main(), kahit na ang operasyon ay nakansela. Suriin ang isCancelled sa loob ng completionBlock upang hindi ma-update ang UI ng maling data. OperationQueue.main — isang thread-safe na pila para sa mga UI operation, kahalintulad ng DispatchQueue.main.

Iwasan ang cyclic dependency — sila ay nagdudulot na wala sa mga operasyon sa cycle ang kailanman magsisimula. Hindi awtomatikong nakikita ng OperationQueue ang mga cycle: kung ang A ay depende sa B, at ang B ay depende sa A, pareho silang mananatili magpakailanman sa ready na estado. Planuhin ang dependency graph nang maaga.