OperationQueue — wat is het, Operation en taakbeheer

Wat is OperationQueue en Operation

OperationQueue is een klasse uit het Foundation-framework die de uitvoering van Operation-objecten beheert. In tegenstelling tot DispatchQueue vereist OperationQueue geen expliciete opgave van serial of concurrent modus — het aantal gelijktijdig uitgevoerde operaties wordt geregeld door de eigenschap maxConcurrentOperationCount. Waarde 1 maakt de wachtrij sequential, elke andere waarde maakt deze concurrent.

Operation is een abstracte klasse die een werkeenheid vertegenwoordigt. Elke operatie heeft een status: ready, executing, finished of cancelled. De statussen zijn compatibel met KVO (Key-Value Observing), waardoor er op wijzigingen kan worden gereageerd — bijvoorbeeld het bijwerken van de UI bij voltooiing van een operatie. Operation beheert automatisch de vlaggen isExecuting en isFinished.

Volgens Apple (2026) gebruikt OperationQueue intern GCD, maar voegt functionaliteit toe die niet beschikbaar is in DispatchQueue: afhankelijkheden, prioriteiten en annulering van operaties. Als de app naar de achtergrond gaat, pauzeert OperationQueue de uitvoering en hervat deze bij terugkeer. OperationQueue houdt ook automatisch rekening met het aantal processorkernen en kiest het optimale aantal threads.

Levenscyclus van Operation

Elke operatie doorloopt vier statussen: pending (wachtend), ready (klaar om te starten), executing (bezig) en finished (voltooid). De status cancelled kan in elke fase vóór voltooiing optreden. Overgangen tussen statussen worden gevolgd via KVO — dit is de basis voor reactieve UI-updates. OperationQueue verwijdert automatisch voltooide operaties uit de wachtrij en stelt afhankelijke operaties op de hoogte dat hun voorwaarde is vervuld, waarna hun uitvoering wordt gestart.

Operation en BlockOperation: implementatie van taken

Operation is een abstracte klasse die het overschrijven van de methode main() of start() vereist. In de methode main() wordt de taakcode geplaatst en de status isExecuting en isFinished worden automatisch beheerd. Voor asynchrone operaties is het overschrijven van start() en handmatig beheer van de statusvlaggen vereist.

BlockOperation is een concrete implementatie van Operation die één of meerdere codeblokken uitvoert. BlockOperation wordt concurrent als er meerdere blokken worden toegevoegd via addExecutionBlock(). De operatie wordt pas voltooid nadat alle toegevoegde blokken zijn uitgevoerd. BlockOperation is een handig alternatief voor eenvoudige taken zonder overerving.

Een eigen Operation maken

Om een aangepaste operatie te maken, erft u van Operation en overschrijft u main(). Controleer binnenin de vlag isCancelled vóór dure operaties om snelle annulering te garanderen. Dit is cruciaal voor het downloaden van grote bestanden of batchverwerking van gegevens. Keuze tussen Operation en BlockOperation hangt af van de complexiteit van de taak: voor eenvoudige eenmalige acties is BlockOperation voldoende, voor herbruikbare logica met status — overerving van Operation.

Afhankelijkheden en prioriteiten van operaties

Afhankelijkheden zijn het belangrijkste voordeel van OperationQueue ten opzichte van DispatchQueue. De methode addDependency(_:) bepaalt dat operatie B pas wordt uitgevoerd nadat operatie A is voltooid. Afhankelijkheden vormen een directed acyclic graph (DAG): bij het toevoegen van een cyclische afhankelijkheid negeert de wachtrij deze en worden de operaties niet gestart.

Prioriteit van een operatie wordt ingesteld met de eigenschap queuePriority met waarden: .veryLow, .low, .normal, .high, .veryHigh. Prioriteit beïnvloedt de startvolgorde onder ready-operaties, maar vervangt afhankelijkheden niet. OperationQueue houdt eerst rekening met afhankelijkheden, daarna met prioriteit onder beschikbare operaties.

Praktisch voorbeeld van afhankelijkheden

Een typisch scenario — het laden van profielgegevens: eerst laden we de gebruiker, vervolgens laden we op basis van zijn id vrienden en berichten. Het instellen van een afhankelijkheid tussen gebruiker laden en vrienden laden garandeert de juiste volgorde zonder geneste completion handlers.

Beperking van parallellisme

De eigenschap maxConcurrentOperationCount beperkt het aantal gelijktijdig uitgevoerde operaties. Waarde 1 creëert een sequential wachtrij, de standaardwaarde (NSOperationQueueDefaultMaxConcurrentOperationCount) — systeemoptimaal, afhankelijk van de huidige belasting van het apparaat. Correcte instelling van deze parameter voorkomt overmatig resourceverbruik: voor het laden van afbeeldingen zijn 4-6 concurrent operaties voldoende, voor CPU-intensieve taken — het aantal processorkernen.

OperationQueue vs DispatchQueue: vergelijking

De keuze tussen OperationQueue en DispatchQueue hangt af van de complexiteit van de taak. DispatchQueue is een lichtgewicht tool voor eenvoudige async-aanroepen. OperationQueue is een zwaardere oplossing voor complexe scenario’s met meerdere onderling verbonden taken. Apple raadt aan om met DispatchQueue te beginnen en alleen naar OperationQueue over te stappen wanneer afhankelijkheden of annulering nodig zijn. Voor de meeste iOS-projecten biedt een combinatie van beide tools een optimale balans tussen prestaties en flexibiliteit.

• DispatchQueue — licht, snel, zonder overhead van Operation-objecten
• OperationQueue — ondersteunt afhankelijkheden, annulering, KVO en prioriteiten
• DispatchQueue — ideaal voor eenvoudige async/asyncAfter-taken en synchronisatie via serial
• OperationQueue — onmisbaar voor stapsgewijze algoritmen met sequentiële fasen
• DispatchQueue — integratie met Swift Concurrency (async/await) via Continuation

Volgens Ray Wenderlich (2025), wordt in grote iOS-projecten OperationQueue gebruikt voor het laden van inhoud met voortgang en annulering, en DispatchQueue voor alle overige async-operaties. De verhouding is ongeveer 20 tot 80 in het voordeel van DispatchQueue.

Codevoorbeelden met OperationQueue in Swift

We bekijken drie voorbeelden: een eenvoudige BlockOperation, een aangepaste Operation met afhankelijkheden en een annuleerbare operatie voor het laden van gegevens.

BlockOperation met completion

Het eenvoudigste geval — voer een blok uit op OperationQueue en verwerk het resultaat via completionBlock. Elke Operation heeft een ingebouwde eigenschap completionBlock die wordt aangeroepen na voltooiing van main().

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

Afhankelijkheden tussen operaties

Afhankelijkheid garandeert dat parseOperation pas start nadat downloadOperation is voltooid. Dit elimineert de noodzaak voor geneste callbacks.

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

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

Annuleerbare aangepaste Operation

Overschrijf main() met periodieke controle van isCancelled. Dit maakt het mogelijk om de operatie onmiddellijk te stoppen bij annulering, zonder te wachten op voltooiing van een dure operatie.

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) }
    }
}

Annulering van operaties en KVO-bewaking

Annulering van een operatie zet de vlag isCancelled op true, maar stopt de reeds gestarte methode main() niet. De code binnen main() moet zelfstandig isCancelled controleren en indien nodig beëindigen. Dit is een architectonische beslissing van Apple — die de ontwikkelaar in staat stelt om bij annulering correct bronnen vrij te geven.

KVO-bewaking van de eigenschappen isFinished en isExecuting maakt het mogelijk om te reageren op voltooiing van operaties zonder expliciete callback. OperationQueue verwijdert voltooide operaties automatisch uit de wachtrij, maar ze blijven in het geheugen zolang er sterke verwijzingen naar zijn. KVO is de basis voor integratie van OperationQueue met reactieve frameworks zoals RxSwift of Combine.

Afhandeling van annulering via KVO

Abonneren op isCancelled via KVO maakt het mogelijk om de UI bij te werken bij annulering van een operatie — bijvoorbeeld het tonen van een placeholder in plaats van een geannuleerde download. De eigenschap isCancelled is KVO-compatibel, wat het handig maakt voor reactieve pipelines.

Beste praktijken voor werken met OperationQueue

Maak geen operaties in grote aantallen — elke Operation is een apart object in het geheugen. Als de taak kort is en geen afhankelijkheden vereist, gebruik dan direct DispatchQueue. OperationQueue is alleen gerechtvaardigd voor complexe scenario’s met expliciete afhankelijkheden, annulering en voortgangsbewaking.

Controleer isCancelled vóór dure operaties binnen de methode main(). Bij het downloaden van bestanden of verwerken van afbeeldingen zorgt controle na elke belangrijke stap voor een snelle reactie op annulering. Gebruik if isCancelled { return } aan het begin van main() en na elke grote operatie.

Beheer completionBlock correct. De eigenschap completionBlock van een operatie wordt aangeroepen na voltooiing van main(), zelfs als de operatie is geannuleerd. Controleer isCancelled binnen completionBlock om te voorkomen dat de UI wordt bijgewerkt met onjuiste gegevens. OperationQueue.main — een thread-veilige wachtrij voor UI-operaties, vergelijkbaar met DispatchQueue.main.

Vermijd cyclische afhankelijkheden — ze leiden ertoe dat geen van de operaties in de cyclus ooit wordt gestart. OperationQueue detecteert cycli niet automatisch: als A afhankelijk is van B en B van A, blijven beide voor altijd in de status ready. Plan de afhankelijkheidsgraaf van tevoren.