MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Objective-C多线程中的NSOperation与队列应用

2022-03-082.6k 阅读

多线程编程基础

在深入探讨NSOperation与队列在Objective-C多线程编程中的应用之前，我们先来回顾一下多线程编程的一些基本概念。

多线程编程允许在一个程序中同时执行多个任务，这些任务被称为线程。线程共享进程的资源，如内存空间，但每个线程有自己的执行上下文，包括程序计数器、寄存器和栈。

在Objective-C中，多线程编程主要用于提高应用程序的响应性和性能。例如，在一个iOS应用中，主线程负责处理用户界面的更新和事件响应。如果在主线程中执行一个耗时操作，如网络请求或文件读取，用户界面将会冻结，直到操作完成。通过使用多线程，可以将这些耗时操作放在后台线程中执行，而主线程继续处理用户交互，提高应用的流畅性。

线程的生命周期

线程的生命周期包括几个阶段：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）。

  1. 新建：当创建一个新的线程对象时，线程处于新建状态。例如，在Objective-C中通过NSThread类创建一个新线程：
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(myTask) object:nil];
  1. 就绪：调用线程的start方法后，线程进入就绪状态，等待CPU调度执行。
[thread start];
  1. 运行：当CPU调度到该线程时，线程进入运行状态，开始执行线程的任务代码。
- (void)myTask {
    // 线程任务代码
}
  1. 阻塞：线程在运行过程中，可能会因为某些原因（如等待资源、睡眠等）进入阻塞状态，暂时停止执行。例如，调用[NSThread sleepForTimeInterval:2.0];会使当前线程睡眠2秒，进入阻塞状态。
  2. 死亡：当线程的任务执行完毕，或者调用[NSThread exit];方法，线程进入死亡状态，生命周期结束。

NSOperation简介

NSOperation是一个抽象类，它代表一个可以异步执行的任务。NSOperation类定义了任务的基本属性和方法，具体的任务执行逻辑需要由它的子类来实现。

NSOperation的子类

  1. NSInvocationOperation：NSInvocationOperation允许将一个已有的方法包装成一个操作。它通过NSInvocation对象来封装方法调用，包括目标对象、方法选择器和方法参数。
NSObject *target = [[NSObject alloc] init];
NSMethodSignature *signature = [target methodSignatureForSelector:@selector(myMethodWithParameter:)];
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
[invocation setTarget:target];
[invocation setSelector:@selector(myMethodWithParameter:)];
id parameter = @"Some Parameter";
[invocation setArgument:&parameter atIndex:2]; // 索引从2开始，0是self，1是_cmd

NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithInvocation:invocation];
  1. NSBlockOperation：NSBlockOperation允许将一个或多个代码块包装成一个操作。可以通过addExecutionBlock:方法添加多个代码块，这些代码块会在操作执行时并行执行（如果在并发队列中）。
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
    // 第一个代码块
    NSLog(@"Block 1 executed");
}];
[blockOperation addExecutionBlock:^{
    // 第二个代码块
    NSLog(@"Block 2 executed");
}];
  1. 自定义子类：开发人员可以继承NSOperation类，并重写main方法来定义自己的任务逻辑。这在需要更复杂的任务控制和状态管理时非常有用。
@interface MyCustomOperation : NSOperation
@end

@implementation MyCustomOperation
- (void)main {
    if (!self.isCancelled) {
        // 自定义任务逻辑
        NSLog(@"MyCustomOperation is running");
    }
}
@end

NSOperation的属性

  1. isExecuting：只读属性，用于判断操作是否正在执行。在自定义NSOperation子类时，如果需要准确跟踪操作的执行状态，可能需要手动管理这个属性。
  2. isFinished：只读属性，用于判断操作是否已经完成。同样，在自定义子类中可能需要手动更新这个属性。
  3. isCancelled：只读属性，用于判断操作是否已被取消。可以通过调用cancel方法来取消操作，在自定义main方法中需要检查这个属性，以便在取消时正确处理任务。
  4. dependencies：只读属性，返回一个包含该操作依赖的其他操作的数组。操作会在其所有依赖操作完成后才开始执行。
NSOperation *operation1 = [[MyCustomOperation alloc] init];
NSOperation *operation2 = [[MyCustomOperation alloc] init];
[operation2 addDependency:operation1];

NSOperationQueue简介

NSOperationQueue是一个用于管理NSOperation对象的队列。它负责调度和执行添加到队列中的操作。

队列类型

  1. 主队列（Main Queue）：主队列与应用程序的主线程相关联。添加到主队列的操作会在主线程中执行。主队列主要用于更新用户界面等需要在主线程执行的任务。可以通过[NSOperationQueue mainQueue]获取主队列。
NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
NSBlockOperation *uiUpdateOperation = [NSBlockOperation blockOperationWithBlock:^{
    // 更新用户界面的代码
    UILabel *label = [[UILabel alloc] initWithFrame:CGRectMake(0, 0, 100, 50)];
    label.text = @"Updated Text";
    [self.view addSubview:label];
}];
[mainQueue addOperation:uiUpdateOperation];
  1. 并发队列（Concurrent Queue）：并发队列允许同时执行多个操作，具体并发数量由系统动态管理。系统提供了全局并发队列，可以通过[NSOperationQueue globalQueueWithPriority:]获取，其中优先级参数可以是NSOperationQueuePriorityHigh、NSOperationQueuePriorityDefault、NSOperationQueuePriorityLow或NSOperationQueuePriorityVeryLow。
NSOperationQueue *concurrentQueue = [NSOperationQueue globalQueueWithPriority:NSOperationQueuePriorityDefault];
NSBlockOperation *networkOperation = [NSBlockOperation blockOperationWithBlock:^{
    // 网络请求代码
    NSURL *url = [NSURL URLWithString:@"https://example.com/api"];
    NSData *data = [NSData dataWithContentsOfURL:url];
    // 处理响应数据
}];
[concurrentQueue addOperation:networkOperation];
  1. 串行队列（Serial Queue）：串行队列一次只执行一个操作，当一个操作完成后，队列才会开始执行下一个操作。可以通过[[NSOperationQueue alloc] init]创建一个串行队列。
NSOperationQueue *serialQueue = [[NSOperationQueue alloc] init];
NSBlockOperation *fileOperation1 = [NSBlockOperation blockOperationWithBlock:^{
    // 文件读取操作1
    NSString *path = [[NSBundle mainBundle] pathForResource:@"file1" ofType:@"txt"];
    NSString *content1 = [NSString stringWithContentsOfFile:path encoding:NSUTF8StringEncoding error:nil];
    NSLog(@"File 1 content: %@", content1);
}];
NSBlockOperation *fileOperation2 = [NSBlockOperation blockOperationWithBlock:^{
    // 文件读取操作2
    NSString *path = [[NSBundle mainBundle] pathForResource:@"file2" ofType:@"txt"];
    NSString *content2 = [NSString stringWithContentsOfFile:path encoding:NSUTF8StringEncoding error:nil];
    NSLog(@"File 2 content: %@", content2);
}];
[serialQueue addOperation:fileOperation1];
[serialQueue addOperation:fileOperation2];

队列操作

  1. 添加操作：通过addOperation:方法可以将一个NSOperation对象添加到队列中。addOperationWithBlock:方法是一个便捷方法，用于直接添加一个代码块作为操作。
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
    // 操作代码
    NSLog(@"Operation is running");
}];
[queue addOperation:operation];

[queue addOperationWithBlock:^{
    // 另一个操作代码
    NSLog(@"Another operation is running");
}];
  1. 设置最大并发数：对于并发队列，可以通过setMaxConcurrentOperationCount:方法设置最大并发操作数。如果设置为1，并发队列就会像串行队列一样工作。
NSOperationQueue *concurrentQueue = [NSOperationQueue globalQueueWithPriority:NSOperationQueuePriorityDefault];
[concurrentQueue setMaxConcurrentOperationCount:2];
  1. 暂停和恢复队列：可以通过setSuspended:YES暂停队列，使队列不再执行新的操作，但已经在执行的操作会继续完成。通过setSuspended:NO恢复队列。
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperationWithBlock:^{
    // 操作1
    NSLog(@"Operation 1 is running");
}];
[queue addOperationWithBlock:^{
    // 操作2
    NSLog(@"Operation 2 is running");
}];
[queue setSuspended:YES]; // 暂停队列
// 一段时间后
[queue setSuspended:NO]; // 恢复队列

NSOperation与队列的高级应用

操作依赖

NSOperation之间可以设置依赖关系，通过addDependency:方法，一个操作可以依赖于一个或多个其他操作。只有当所有依赖的操作完成后，该操作才会开始执行。

NSOperation *operation1 = [[MyCustomOperation alloc] init];
NSOperation *operation2 = [[MyCustomOperation alloc] init];
NSOperation *operation3 = [[MyCustomOperation alloc] init];

[operation2 addDependency:operation1];
[operation3 addDependency:operation2];

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:operation1];
[queue addOperation:operation2];
[queue addOperation:operation3];

在这个例子中，operation1会首先执行，完成后operation2开始执行，operation2完成后operation3开始执行。

操作优先级

NSOperation有一个queuePriority属性，可以设置操作的优先级。优先级高的操作会在优先级低的操作之前执行（在同一队列中）。优先级取值包括NSOperationQueuePriorityHigh、NSOperationQueuePriorityAboveNormal、NSOperationQueuePriorityNormal、NSOperationQueuePriorityBelowNormal和NSOperationQueuePriorityLow。

NSBlockOperation *highPriorityOperation = [NSBlockOperation blockOperationWithBlock:^{
    // 高优先级操作代码
    NSLog(@"High priority operation is running");
}];
highPriorityOperation.queuePriority = NSOperationQueuePriorityHigh;

NSBlockOperation *lowPriorityOperation = [NSBlockOperation blockOperationWithBlock:^{
    // 低优先级操作代码
    NSLog(@"Low priority operation is running");
}];
lowPriorityOperation.queuePriority = NSOperationQueuePriorityLow;

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:highPriorityOperation];
[queue addOperation:lowPriorityOperation];

在这个例子中，highPriorityOperation会在lowPriorityOperation之前执行。

操作完成通知

可以通过NSOperation的completionBlock属性设置一个代码块，当操作完成时会自动执行这个代码块。这在需要在操作完成后执行一些后续任务时非常有用。

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
    // 操作代码
    NSLog(@"Operation is running");
}];
operation.completionBlock = ^{
    // 操作完成后的代码
    NSLog(@"Operation has completed");
};

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:operation];

线程安全与资源管理

在多线程编程中，线程安全是一个重要的问题。由于多个线程可能同时访问共享资源，如变量、文件等，如果处理不当，可能会导致数据竞争和不一致的问题。

锁（Lock）

锁是一种常用的线程同步机制，用于保护共享资源。在Objective-C中，可以使用NSLock类来实现简单的锁。

NSLock *lock = [[NSLock alloc] init];
- (void)accessSharedResource {
    [lock lock];
    // 访问共享资源的代码
    static int sharedVariable = 0;
    sharedVariable++;
    NSLog(@"Shared variable value: %d", sharedVariable);
    [lock unlock];
}

在这个例子中，lock对象用于确保在任何时刻只有一个线程可以访问sharedVariable，避免了数据竞争。

信号量（Semaphore）

NSCondition类提供了一种更灵活的线程同步机制，类似于信号量。它可以用于线程之间的通信和同步，例如一个线程等待另一个线程完成某个任务后再继续执行。

NSCondition *condition = [[NSCondition alloc] init];
- (void)producer {
    [condition lock];
    // 生产数据的代码
    NSLog(@"Producing data");
    [condition signal];
    [condition unlock];
}

- (void)consumer {
    [condition lock];
    [condition wait];
    // 消费数据的代码
    NSLog(@"Consuming data");
    [condition unlock];
}

在这个例子中，consumer线程会等待producer线程发送信号后才会继续执行。

性能优化与注意事项

  1. 避免过度使用多线程：虽然多线程可以提高性能，但过多的线程会增加系统开销，如线程创建、调度和上下文切换的开销。在设计多线程方案时，需要权衡任务的复杂度和线程数量。
  2. 合理使用队列：根据任务的特性选择合适的队列类型。例如，用户界面更新任务应该放在主队列，而耗时的计算任务可以放在并发队列。
  3. 优化资源访问：在多线程环境中，尽量减少对共享资源的访问频率，并且使用合适的线程同步机制来保护共享资源。
  4. 错误处理：在多线程代码中，要注意错误处理。例如，在网络请求操作中，如果一个线程发生错误，需要确保其他相关线程能够正确处理这个错误，避免应用程序崩溃。

通过深入理解NSOperation与队列的原理和应用，结合合理的线程安全机制和性能优化策略，开发人员可以编写出高效、稳定的多线程Objective-C应用程序。无论是iOS应用开发还是其他基于Objective-C的项目，多线程编程都是提高应用性能和用户体验的重要手段。