NSOperationQueue voor complexe taken
Ontdek NSOperation en NSOperationQueue voor een meer gestructureerde en beheersbare uitvoering van gelijktijdige taken, inclusief afhankelijkheden.
NSOperationQueue voor complexe taken is een gratis Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps bevat in totaal 4 lessen.
Waarom NSOperationQueue?
Je hebt Grand Central Dispatch (GCD) geleerd voor gelijktijdige taken. Hoewel GCD krachtig is, kan het complex worden bij ingewikkeld taakbeheer.
NSOperationQueue biedt een manier op hoger niveau, gebaseerd op objectoriëntatie, om gelijktijdigheid af te handelen. Deze bouwt voort op GCD en biedt meer controle en functies, zoals afhankelijkheden, annulering en statusbeheer.
Wat is NSOperation?
De kern van NSOperationQueue is NSOperation. Dit is een abstracte klasse die één werkeenheid vertegenwoordigt die gelijktijdig kan worden uitgevoerd.
Je maakt niet rechtstreeks een instantie van NSOperation. In plaats daarvan gebruik je de concrete subklassen ervan of maak je eigen aangepaste subklassen om specifieke taken te definiëren.
- Kapselt werk in: elke bewerking is een zelfstandige taak.
- Beheert de status: bewerkingen hebben statussen zoals "ready", "executing" en "finished".
- Ondersteunt afhankelijkheden: bewerkingen kunnen ervan afhankelijk zijn dat andere bewerkingen eerst worden voltooid.
Je eigen bewerking bouwen
Als je een aangepaste bewerking wilt maken, maak je een subklasse van NSOperation en overschrijf je de methode main. Hier komt de logica van je taak te staan.
Vergeet niet je bewerking als "finished" te markeren wanneer deze klaar is, vooral bij asynchrone bewerkingen. Bij synchrone bewerkingen handelt main dit af.
Probeer deze eenvoudige aangepaste bewerking uit te voeren:
#import <Foundation/Foundation.h>
// CustomOperation.h
@interface CustomOperation : NSOperation
@end
// CustomOperation.m
@implementation CustomOperation
- (void)main {
if (self.isCancelled) {
return; // Always check for cancellation
}
NSLog(@"Custom operation started!");
// Simulate some work
[NSThread sleepForTimeInterval:1.0];
NSLog(@"Custom operation finished!");
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
CustomOperation *op = [[CustomOperation alloc] init];
[op start]; // Manually start for demo
}
return 0;
}Eenvoudige taken met BlockOperation
Voor eenvoudigere taken waarvoor geen aangepaste subklasse nodig is, is NSBlockOperation ideaal. Hiermee kun je een of meer codeblokken als een bewerking verpakken.
Dit wordt vaak gebruikt voor snelle, eenmalige taken zonder de extra overhead van het maken van een nieuwe klasse.
Zo gebruik je het:
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSBlockOperation *blockOp = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"Block operation running!");
[NSThread sleepForTimeInterval:0.5];
NSLog(@"Block operation done!");
}];
[blockOp start]; // Manually start for demo
}
return 0;
}Uitvoeren met NSOperationQueue
Om concurrency echt te benutten, voeg je bewerkingen toe aan een NSOperationQueue. De wachtrij beheert de uitvoering van bewerkingen, vaak gelijktijdig.
De wachtrij bepaalt wanneer bewerkingen worden gestart op basis van hun gereedheid en afhankelijkheden. De verwerking met threads wordt voor je geregeld.
Bekijk hoe beide bewerkingen gelijktijdig worden uitgevoerd:
#import <Foundation/Foundation.h>
@interface CustomOperation : NSOperation
@end
@implementation CustomOperation
- (void)main {
if (self.isCancelled) return;
NSLog(@"Custom operation started!");
[NSThread sleepForTimeInterval:1.0];
NSLog(@"Custom operation finished!");
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
CustomOperation *op1 = [[CustomOperation alloc] init];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"Block operation started!");
[NSThread sleepForTimeInterval:0.5];
NSLog(@"Block operation finished!");
}];
[queue addOperation:op1];
[queue addOperation:op2];
// Wait for all operations to complete
[queue waitUntilAllOperationsAreFinished];
NSLog(@"All operations completed!");
}
return 0;
}Taken koppelen met afhankelijkheden
Een van de krachtigste functies van NSOperation is het instellen van afhankelijkheden. Je kunt een bewerking zo configureren dat deze pas start nadat een andere specifieke bewerking (of een reeks bewerkingen) is voltooid.
Dit is essentieel voor taken die in een bepaalde volgorde moeten worden uitgevoerd, zodat de consistentie van gegevens of een correcte werkstroom wordt gewaarborgd.
Zie hoe "Op B" op "Op A" wacht:
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSBlockOperation *opA = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"Operation A running...");
[NSThread sleepForTimeInterval:1.0];
NSLog(@"Operation A done!");
}];
NSBlockOperation *opB = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"Operation B running...");
[NSThread sleepForTimeInterval:0.5];
NSLog(@"Operation B done!");
}];
// Op B depends on Op A
[opB addDependency:opA];
[queue addOperation:opA];
[queue addOperation:opB];
[queue waitUntilAllOperationsAreFinished];
NSLog(@"All dependent operations completed!");
}
return 0;
}Taken netjes stoppen
Bewerkingen kunnen worden geannuleerd. Dat is belangrijk wanneer de gebruiker het stoppen initieert of wanneer een taak niet langer relevant is.
Wanneer een bewerking wordt geannuleerd, wordt de eigenschap isCancelled ingesteld op YES. Je main-methode (of je blok) moet deze eigenschap regelmatig controleren en netjes afsluiten als de waarde waar is.
Een bewerking die al is gestart, kan nog wat werk voltooien voordat isCancelled wordt gecontroleerd.
#import <Foundation/Foundation.h>
@interface CancellableOperation : NSOperation
@end
@implementation CancellableOperation
- (void)main {
for (int i = 0; i < 5; i++) {
if (self.isCancelled) {
NSLog(@"Operation was cancelled early!");
return;
}
NSLog(@"Working... %d", i);
[NSThread sleepForTimeInterval:0.2];
}
NSLog(@"Operation finished normally.");
}
@end
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
CancellableOperation *op = [[CancellableOperation alloc] init];
[queue addOperation:op];
// Wait a short time then try to cancel
[NSThread sleepForTimeInterval:0.3];
[op cancel];
NSLog(@"Attempted to cancel operation.");
[queue waitUntilAllOperationsAreFinished];
NSLog(@"Queue finished.");
}
return 0;
}Acties na uitvoering
Soms moet je een actie pas uitvoeren nadat een bewerking is voltooid, ongeacht of deze is geslaagd of geannuleerd.
Elke NSOperation heeft een eigenschap completionBlock. Dit blok wordt op een willekeurige thread uitgevoerd zodra de main-methode van de bewerking (of de blokken voor NSBlockOperation) is voltooid.
Gebruik dit voor opruimwerk of om de gebruikersinterface bij te werken (vergeet niet om updates van de gebruikersinterface naar de hoofdthread te sturen!).
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"Operation running...");
[NSThread sleepForTimeInterval:0.5];
}];
op.completionBlock = ^{
NSLog(@"Operation completion block executed!");
// If updating UI, dispatch to main thread:
// dispatch_async(dispatch_get_main_queue(), ^{ /* UI update */ });
};
[queue addOperation:op];
[queue waitUntilAllOperationsAreFinished];
NSLog(@"All done!");
}
return 0;
}Parallelisme beheren
Een NSOperationQueue kan meerdere bewerkingen gelijktijdig uitvoeren. Je kunt dit gedrag beheren met de eigenschap maxConcurrentOperationCount.
1: Bewerkingen worden serieel uitgevoerd (één tegelijk).NSOperationQueueDefaultMaxConcurrentOperationCount(meestal -1): De wachtrij bepaalt het optimale aantal op basis van de systeemomstandigheden.- Elk positief geheel getal: Beperkt het aantal bewerkingen dat gelijktijdig wordt uitgevoerd.
Dit helpt uitputting van systeembronnen te voorkomen en de werkbelasting te beheren.
Controleer je begrip
Test je kennis van NSOperation en NSOperationQueue.
Herhaling van NSOperationQueue
Goed gedaan! Je hebt NSOperation en NSOperationQueue verkend.
- NSOperation vertegenwoordigt één werkeenheid.
- NSOperationQueue beheert de uitvoering van bewerkingen en biedt een abstractie op een hoger niveau boven GCD.
- Belangrijke functies zijn afhankelijkheden, annulering, voltooiingsblokken en controle over gelijktijdigheid.
- Gebruik
NSBlockOperationvoor eenvoudige taken en aangepaste subklassen voor complexe, herbruikbare bewerkingen.
Dit krachtige framework helpt je robuuste en beheersbare toepassingen te bouwen die gelijktijdige verwerking gebruiken.
Leer Objective-C met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “NSOperationQueue voor complexe taken” gratis?
Ja — de volledige tekst van “NSOperationQueue voor complexe taken” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps bevat in totaal 4 lessen.
Wat leer ik in “NSOperationQueue voor complexe taken”?
Ontdek NSOperation en NSOperationQueue voor een meer gestructureerde en beheersbare uitvoering van gelijktijdige taken, inclusief afhankelijkheden. Je oefent met Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps te beginnen?
Ervaring vooraf is niet nodig. Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “NSOperationQueue voor complexe taken”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps?
Ja. Elke les over Objective-C-iOS-ontwikkeling voor legacy- en bedrijfsapps bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- NSURLSession voor API-aanroepen
- Grand Central Dispatch (GCD)
- NSOperationQueue voor complexe taken
- JSON parsen met NSJSONSerialization