0Pricing
Objective-C iOS Development for Legacy & Enterprise Apps · Leçon

NSOperationQueue pour les tâches complexes

Découvrez NSOperation et NSOperationQueue pour exécuter des tâches concurrentes de manière plus structurée et maîtrisable, notamment avec des dépendances.

NSOperationQueue pour les tâches complexes est une leçon Objective-C iOS Development for Legacy & Enterprise Apps gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Objective-C iOS Development for Legacy & Enterprise Apps, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Objective-C iOS Development for Legacy & Enterprise Apps comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Why NSOperationQueue?

You've learned about Grand Central Dispatch (GCD) for concurrent tasks. While powerful, GCD can become complex for intricate task management.

NSOperationQueue offers a higher-level, object-oriented way to handle concurrency. It builds on top of GCD, providing more control and features like dependencies, cancellation, and state management.

What is NSOperation?

At the core of NSOperationQueue is NSOperation. It's an abstract class representing a single unit of work that can be executed concurrently.

You don't instantiate NSOperation directly. Instead, you use its concrete subclasses or create your own custom subclasses to define specific tasks.

  • Encapsulates work: Each operation is a self-contained task.
  • Manages state: Operations have states like "ready," "executing," "finished."
  • Supports dependencies: Operations can depend on others completing first.

Build Your Own Operation

To create a custom operation, you subclass NSOperation and override its main method. This is where your task's logic goes.

Remember to mark your operation as "finished" when done, especially for asynchronous operations. For synchronous operations, main handles it.

Try running this simple custom operation:

#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;
}

Simple Tasks with BlockOperation

For simpler tasks that don't require a custom subclass, NSBlockOperation is perfect. It allows you to wrap one or more blocks of code as an operation.

This is often used for quick, one-off tasks without the overhead of creating a new class.

Here's how to use it:

#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;
}

Executing with NSOperationQueue

To truly leverage concurrency, you add operations to an NSOperationQueue. The queue manages the execution of operations, often concurrently.

The queue decides when to start operations based on their readiness and dependencies. It handles the threading for you.

Observe how both operations run concurrently:

#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;
}

Chaining Tasks with Dependencies

One of NSOperation's most powerful features is setting dependencies. An operation can be configured to only start after another specific operation (or set of operations) has finished.

This is crucial for tasks that must be executed in a particular order, ensuring data consistency or proper workflow.

Notice how "Op B" waits for "Op A":

#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;
}

Stopping Tasks Gracefully

Operations can be cancelled, which is vital for user-initiated stops or when a task becomes irrelevant.

When an operation is cancelled, its isCancelled property becomes YES. Your main method (or block) should regularly check this property and exit gracefully if it's true.

An operation that has already started might still complete some work before checking isCancelled.

#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;
}

Post-Execution Actions

Sometimes you need to perform an action only after an operation has finished, regardless of whether it succeeded or was cancelled.

Every NSOperation has a completionBlock property. This block is executed on an arbitrary thread once the operation's main method (or blocks for NSBlockOperation) has completed.

Use it for cleanup or to update the UI (remember to dispatch UI updates to the main thread!).

#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;
}

Managing Parallelism

An NSOperationQueue can execute multiple operations concurrently. You can control this behavior using the maxConcurrentOperationCount property.

  • 1: Operations run serially (one at a time).
  • NSOperationQueueDefaultMaxConcurrentOperationCount (usually -1): The queue decides the optimal number based on system conditions.
  • Any positive integer: Limits the number of operations running simultaneously.

This helps prevent resource exhaustion and manage workload.

Check Your Understanding

Test your knowledge on NSOperation and NSOperationQueue.

NSOperationQueue Recap

Great job! You've explored NSOperation and NSOperationQueue.

  • NSOperation represents a single unit of work.
  • NSOperationQueue manages the execution of operations, providing a higher-level abstraction over GCD.
  • Key features include dependencies, cancellation, completion blocks, and control over concurrency.
  • Use NSBlockOperation for simple tasks and custom subclasses for complex, reusable operations.

This powerful framework helps you build robust and manageable concurrent applications.

Questions Fréquemment Posées

La leçon « NSOperationQueue pour les tâches complexes » est-elle gratuite ?

Oui — le texte complet de « NSOperationQueue pour les tâches complexes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Objective-C iOS Development for Legacy & Enterprise Apps, passe à CoddyKit PRO. Le cours Objective-C iOS Development for Legacy & Enterprise Apps comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « NSOperationQueue pour les tâches complexes » ?

Découvrez NSOperation et NSOperationQueue pour exécuter des tâches concurrentes de manière plus structurée et maîtrisable, notamment avec des dépendances. Tu pratiques Objective-C iOS Development for Legacy & Enterprise Apps avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Objective-C iOS Development for Legacy & Enterprise Apps ?

Aucune expérience préalable n'est requise. Objective-C iOS Development for Legacy & Enterprise Apps sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « NSOperationQueue pour les tâches complexes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Objective-C iOS Development for Legacy & Enterprise Apps ?

Oui. Chaque leçon Objective-C iOS Development for Legacy & Enterprise Apps inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. NSURLSession pour les appels d’API
  2. Grand Central Dispatch (GCD)
  3. NSOperationQueue pour les tâches complexes
  4. Analyser du JSON avec NSJSONSerialization
← Retour à Objective-C iOS Development for Legacy & Enterprise Apps