iOS并发编程实践：NSOperation深入解析

最新推荐文章于 2025-03-14 18:15:26 发布

浮华ya

最新推荐文章于 2025-03-14 18:15:26 发布

阅读量1k

点赞数 8

本文链接：https://blog.youkuaiyun.com/weixin_36178216/article/details/143642999

版权

本文还有配套的精品资源，点击获取

简介：在iOS开发中，掌握多线程技术是核心技能之一。本源码包"NSOperationTest"提供了一个深入研究NSOperation及其相关概念的实践平台。NSOperation是苹果公司提供的一个高级多任务处理框架，基于GCD之上，允许开发者方便地管理和控制任务执行。通过此项目，开发者可以学习如何使用NSOperation和NSOperationQueue来执行异步任务、控制任务执行顺序、管理任务状态、实现依赖和取消机制，以及利用NSBlockOperation简化代码结构。本源码是学习并发编程和提升iOS应用性能的实用资源。 IOS应用源码——NSOperationTest.rar

1. 多线程技术在iOS开发中的重要性

在移动应用开发过程中，尤其是在iOS平台，多线程技术的应用对于构建高性能和流畅的用户体验至关重要。随着应用功能的日趋复杂化，对数据的处理、网络通信和后台任务的需求日益增加，传统的单线程模型已经无法满足现代应用的需求。多线程技术能够提高应用的响应速度，避免界面卡顿，并有效利用多核处理器的计算能力，提高资源的使用效率。

在iOS平台上，开发者主要有两种方式实现多线程编程：Grand Central Dispatch (GCD) 和 NSOperation。GCD 提供了一个底层的、基于C的API，适用于需要高性能和精细控制的场景；而 NSOperation 则提供了一个面向对象的、更高级的抽象，使得多线程任务的管理更为简便和灵活。NSOperation 通过定义操作对象，并将这些操作添加到操作队列（NSOperationQueue）中来管理多线程任务，它支持依赖性管理、取消操作、状态监控以及并行与串行执行等多种特性，为iOS开发者提供了一种更符合面向对象编程范式的方式来实现多线程编程。

了解和掌握这些多线程技术对于优化iOS应用的性能、提升用户体验、降低开发复杂度都有着不可替代的作用。接下来的章节中，我们将深入探讨NSOperation框架的具体应用，以及如何在iOS开发中利用这一框架来实现高效、可控的多线程编程。

2. NSOperation框架简介及抽象

NSOperation框架是iOS多线程编程中一个重要的抽象层，它为开发者提供了一个面向对象的方式来处理复杂的异步操作。它允许开发者定义一系列的操作，并控制这些操作的执行顺序和依赖关系，从而实现了更高级别的多线程编程抽象。

2.1 NSOperation框架概述

2.1.1 NSOperation框架的定义与特点

NSOperation是一个抽象的基类，开发者不能直接实例化它。它主要用来表示一个单独的任务单元，这个单元可以通过多种方式执行，比如并发执行或同步执行。NSOperation对象通常被添加到NSOperationQueue中进行管理。

NSOperation的主要特点包括： - 任务封装 ：NSOperation允许开发者将代码封装成一个单元，这个单元就是一个任务。 - 依赖管理 ：NSOperation支持操作之间的依赖关系，可以确保在依赖的任务完成之前，当前任务不会被执行。 - 状态管理 ：NSOperation提供了操作状态的管理，包括操作是否正在执行、已经完成、已经取消等。 - 并发控制 ：NSOperation可以控制任务的并发执行，开发者可以设置最大并发操作数。

2.1.2 NSOperation与GCD的关系及抽象概念

NSOperation与Grand Central Dispatch (GCD) 是两种不同的并发编程模型，它们在iOS开发中广泛使用。NSOperation提供了面向对象的方式来管理操作，而GCD则提供了基于C语言的块（block）和队列模型。

NSOperation和GCD之间的关系可以概括为： - NSOperation的底层实现 ：NSOperation内部使用GCD实现，这意味着NSOperation的很多操作最终都会被转换为GCD的任务。 - 抽象层与控制层 ：NSOperation作为抽象层，给开发者带来了更多的控制和灵活性，比如操作依赖和状态管理。 - 适用场景 ：对于需要更多控制的操作，NSOperation更合适；对于简单的并发任务，GCD则更加高效。

2.2 基于GCD的NSOperation抽象机制

2.2.1 GCD核心概念及其在NSOperation中的应用

Grand Central Dispatch (GCD) 是iOS并发编程的核心技术之一，它提供了一个高度优化的调度队列系统。GCD使用队列来管理任务，并将任务分配给可用的线程。

GCD的核心概念包括： - 队列（Queue） ：GCD有两个主要类型的队列，即串行队列和并发队列。串行队列按照任务添加的顺序执行任务，而并发队列可以同时执行多个任务。 - 同步与异步 ：同步执行意味着任务会在当前线程中执行，直到完成。异步执行则意味着任务会被分派到另一个线程，当前线程则继续执行其他任务。

在NSOperation中，GCD的应用表现为： - NSOperationQueue的内部实现 ：NSOperationQueue使用GCD来管理操作队列，这使得开发者可以利用GCD的高效性能。 - 操作的执行 ：NSOperation对象执行的代码块或任务，最终会通过GCD来调度执行。

2.2.2 如何通过GCD简化多线程代码编写

GCD的设计宗旨是为了简化多线程代码的编写，它通过提供一个高层次的抽象来降低并发编程的复杂性。利用GCD，开发者可以用更少的代码实现复杂的多线程任务。

简化多线程编程的GCD方法包括： - 使用 dispatch_async ：这个函数可以异步地执行一个任务，它非常适合用于那些不会阻塞当前线程的任务。你可以将复杂的操作放在一个 dispatch_async 调用中，代码简洁而高效。 - 使用 dispatch_sync ： dispatch_sync 函数可以同步地执行一个任务。虽然它可能会导致死锁或阻塞线程，但它在某些情况下也是必要的。 - 队列管理 ：通过创建多个队列，并控制它们的执行顺序，你可以实现复杂的多线程逻辑。例如，你可以使用串行队列来确保任务以特定顺序执行，而并发队列则可以加速任务的执行。

GCD极大地简化了并发编程的难度，使得开发者不需要直接管理线程，只需要关注任务的调度。通过利用GCD的强大功能，NSOperation变得更为强大和灵活。

// 示例代码：使用GCD来异步执行一个任务
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行一个复杂的后台任务
    [self complexBackgroundTask];
    // 任务完成后，回到主线程更新UI
    dispatch_async(dispatch_get_main_queue(), ^{
        [self updateUI];
    });
});

在上述代码中， dispatch_async 函数被用来执行一个复杂任务，并且在任务完成后，再将控制权交回给主线程来更新用户界面。这种模式在iOS应用开发中非常常见，它展示了GCD如何简化多线程编程的实践。

通过这个简单的例子，你可以看到GCD在NSOperation框架中是如何被广泛使用的。它不仅减少了编写和管理多线程代码的复杂性，而且提高了代码的可读性和可维护性。

3. NSOperation对象和NSOperationQueue的创建与应用

3.1 创建NSOperation对象

3.1.1 NSOperation对象的基本属性和方法

NSOperation是NSOperationQueue并发编程模型中的核心对象，它代表一个单一的操作。NSOperation本身是一个抽象基类，不能直接实例化，开发者通常需要使用它的子类，如NSInvocationOperation或NSBlockOperation，或者是创建自定义的NSOperation子类来执行实际的操作。一个NSOperation对象主要通过下面几个属性和方法来定义：

isExecuting : 表示操作是否正在执行。
isFinished : 表示操作是否已经结束。
isCancelled : 表示操作是否已被取消。
dependencies : 表示操作依赖的其他操作集合。

NSOperation类提供了以下方法来控制操作的执行：

start() : 开始执行操作。
main() : 操作的执行入口，如果使用NSBlockOperation，通常在block中编写具体的执行代码。
cancel() : 用于取消操作。

开发者可以通过覆写上述方法来实现自定义的逻辑。例如，一个简单的NSBlockOperation的实现可能如下所示：

let operation = NSBlockOperation {
    // 执行具体的任务
}

// 启动操作
operation.start()

3.1.2 不同类型NSOperation的使用场景和特点

在iOS开发中，NSOperation的子类提供了不同的使用场景和特点：

NSInvocationOperation ：允许开发者使用任意方法作为操作的入口点。它适合于那些需要异步执行简单任务的情况。
NSBlockOperation ：使用闭包块来执行操作，非常适合快速创建简单的并发任务。
自定义NSOperation：适合复杂操作，可以通过覆写 main() 和 isFinished 等方法来控制任务的执行和完成状态。

在选择使用何种类型的NSOperation时，通常需要考虑以下因素：

是否需要任务依赖关系。
任务执行的复杂程度。
是否需要对任务执行进行更多的控制。

3.2 使用NSOperationQueue管理操作

3.2.1 NSOperationQueue的初始化和配置

NSOperationQueue提供了管理和执行NSOperation对象的容器，是NSOperation并发执行的核心组件。通过NSOperationQueue，开发者能够控制并发执行的最大操作数、操作的执行顺序以及取消和暂停执行等。

创建NSOperationQueue实例，可以使用默认的队列或者自定义队列。下面是如何使用默认队列的例子：

let operationQueue = OperationQueue()

配置NSOperationQueue时，可以设置以下几个关键属性：

maxConcurrentOperationCount : 设置并发执行操作的最大数量。
name : 操作队列的名称，有助于调试。
QualityOfService : 指定操作的优先级和质量服务要求。

通过配置这些属性，开发者能够有效地控制操作的执行顺序和优先级，以优化应用性能。

3.2.2 线程优先级和队列容量的设置

线程优先级和队列容量的设置是NSOperationQueue中非常重要的配置项，能够影响任务的执行顺序和效率。

线程优先级 : NSOperationQueue通过QualityOfService（QoS）类别来确定线程优先级。这个类别决定系统如何分配资源给特定的任务。在iOS开发中，常见的QoS类别包括：
background ：用于后台任务，如文件同步。
Utility ：用于执行用户不受直接影响的任务。
default ：常规任务，如网络访问。
userInteractive ：用于需要快速响应的用户界面任务。例如，设置队列的QoS类别可以使用如下代码：

swift operationQueue.qualityOfService = .userInteractive

队列容量 : 通过 maxConcurrentOperationCount 属性来设置并发执行操作的最大数量。默认情况下，这个值是-1，表示队列会自动决定并发操作的数量。如果你需要限制并发操作的数量，可以将此值设置为具体的整数：

swift operationQueue.maxConcurrentOperationCount = 2

通过合理配置线程优先级和队列容量，开发者可以确保应用中的关键任务可以得到资源优先分配，同时也能避免因为过多并发操作导致的资源竞争和性能下降。

以上就是本章对NSOperation对象和NSOperationQueue的创建与应用的详细讲解。通过理解并掌握本章内容，开发者可以在实际应用中更有效地使用多线程技术来提升应用性能和用户体验。

4. 自定义NSOperation子类和操作依赖的实现

NSOperation框架的强大之处在于它不仅提供了基本的多线程操作，还允许开发者通过继承NSOperation来创建自定义操作类，以满足特定的业务需求。此外，NSOperation还支持设置操作之间的依赖关系，这为复杂任务的管理和协调提供了极大的便利。在本章节中，我们将深入探讨自定义NSOperation子类的方法和实现操作依赖的技巧。

4.1 自定义NSOperation子类

4.1.1 子类化NSOperation的基本步骤

NSOperation是一个抽象类，它不能被直接实例化。若要创建自定义的操作，我们需要子类化NSOperation。以下是实现自定义NSOperation子类的基本步骤：

创建一个新的NSOperation子类。
重写 start 方法来定义操作执行的代码。
可选地重写 isReady 、 isExecuting 和 isFinished 等方法以提供更精细的状态管理。
在 start 方法中，使用 main 方法来执行实际的任务。

下面是一个简单的示例代码：

class CustomOperation: NSOperation {
    override func main() {
        // 执行实际的任务代码
        // 示例：打印当前线程的标识符
        print("Operation started on thread: \(Thread.current)")
    }
}

4.1.2 实现自定义操作的业务逻辑

在自定义操作类中，你可以实现任何业务逻辑。例如，如果你正在处理图像，你的操作可能会下载、处理、然后保存图像。这通常涉及到调用其他类或API，如URLSession进行网络请求。

自定义操作能够极大地增强你的应用的灵活性和可维护性，因为它们将多线程逻辑封装在可重用和可测试的单元中。

4.2 实现操作依赖

4.2.1 操作依赖的设置和管理

NSOperation提供了 addDependency(_:) 方法来设置操作之间的依赖关系。当一个操作依赖于另一个操作时，它将等待其依赖的操作完成后再开始执行。这对于顺序化或有条件地执行操作非常有用。

例如，如果操作A产生了一些数据，而操作B需要使用这些数据，那么你可以这样设置依赖关系：

let operationA = CustomOperation()
let operationB = CustomOperation()

// 设置operationB依赖于operationA
operationB.addDependency(operationA)

// 将操作添加到NSOperationQueue
let queue = NSOperationQueue()
queue.addOperations([operationA, operationB], waitUntilFinished: false)

4.2.2 高级依赖关系的构建方法

在某些情况下，依赖关系可能会变得复杂，可能会有多对多的关系。为了更有效地管理这些依赖，你可以创建一个专门用于管理依赖关系的工具类，或者使用NSOperationQueue提供的方法来添加操作。

例如，使用NSOperationQueue的 addOperationWithBlock 方法：

let queue = NSOperationQueue()

queue.addOperationWithBlock {
    // 在这里执行操作1
}

queue.addOperationWithBlock { [weak self] in
    // 等待上面的操作完成后执行操作2
    // 例如：self?.operation1.waitUntilFinished()
    // 在这里执行操作2
}

请注意，依赖关系的错误管理可能导致死锁或循环依赖，因此在实现时需要格外小心。务必确保每项操作在逻辑上都是独立的，避免不必要的依赖。

在本章节中，我们探讨了NSOperation框架如何通过自定义子类和设置操作依赖来实现复杂多线程任务的管理。自定义NSOperation子类为开发者提供了更高的灵活性和控制能力，而依赖管理则增强了任务的可预测性和稳定性。通过这些高级技术，开发者可以构建更健壮和响应更快的应用程序。

5. 操作的状态管理及其监控（KVO）

5.1 状态管理基础

5.1.1 NSOperation的状态及其转换逻辑

NSOperation 是一个抽象基类，它定义了几个关键的状态，这些状态控制着操作的执行流程。每个 NSOperation 对象都有一个状态，这个状态可以是 notScheduled （未调度）、 Ready （准备就绪）、 Executing （正在执行）、 Finished （已结束）。通过这些状态，我们能够监控和管理操作的执行。

状态转换逻辑如下： - notScheduled ：这是操作对象的初始状态。当操作对象被创建但尚未添加到操作队列中时，它处于这个状态。 - Ready ：操作对象被添加到操作队列中后，如果它的依赖操作已经完成，则它会转换到这个状态，表明它已经准备好执行了。 - Executing ：当操作对象开始执行其业务逻辑时，它会转换到这个状态。 - Finished ：操作完成执行后，无论成功还是失败，都会进入这个状态。

理解这些状态及其转换逻辑对于维护线程安全和避免资源冲突至关重要。

5.1.2 状态变化对操作执行的影响

状态的变化直接影响操作对象的执行行为。对于那些已经处于 Executing 状态的操作，如果状态变为 Finished ，那么这个操作会被队列中的其他操作或队列本身感知到，从而导致这些操作进行相应的处理，比如取消后续操作或者停止处理。

当一个操作依赖的其他操作完成后，该操作可能从 notScheduled 或 Ready 状态被自动添加到队列中并开始执行。这能确保依赖关系得到尊重，同时又保持了操作队列的流畅运行。

理解状态变化对执行的影响，可以帮助开发者编写出更可靠和高效的并发代码。

5.2 KVO 在状态监控中的应用

5.2.1 KVO 机制的基本原理

键值观察（Key-Value Observing，简称 KVO）是 Objective-C 中的一种观察者模式实现，允许对象观察另一个对象的属性变化。当被观察对象的属性发生变化时，观察者对象会自动收到通知。

对于 NSOperation，我们可以添加观察者来观察 isExecuting 和 isFinished 这两个属性。这两个属性反映了操作的实时状态，KVO 机制可以让我们在状态改变时得到实时的反馈。

5.2.2 使用 KVO 监控 NSOperation 状态变化

要监控 NSOperation 的状态变化，首先需要对特定的 NSOperation 对象添加观察者，注册感兴趣的属性。下面是一个代码示例，展示了如何为 NSOperation 添加 KVO 观察者：

// 假设 myOperation 是我们要监控的 NSOperation 对象
NSString *executeKey = @"isExecuting";
NSString *finishedKey = @"isFinished";

[self.myOperation addObserver:self
                   forKeyPath:executeKey
                      options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
                      context:nil];

[self.myOperation addObserver:self
                   forKeyPath:finishedKey
                      options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
                      context:nil];

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary<NSKeyValueChangeKey,id> *)change
                       context:(void *)context {
    if ([keyPath isEqualToString:executeKey]) {
        BOOL isExecuting = [change[NSKeyValueChangeNewKey] boolValue];
        // 执行中的状态变更逻辑
    } else if ([keyPath isEqualToString:finishedKey]) {
        BOOL isFinished = [change[NSKeyValueChangeNewKey] boolValue];
        // 完成的状态变更逻辑
    }
}

// 当不再需要监控时，要移除观察者
[self.myOperation removeObserver:self forKeyPath:executeKey];
[self.myOperation removeObserver:self forKeyPath:finishedKey];

通过 KVO，我们可以实现对 NSOperation 状态变化的实时监控，从而执行一些额外的逻辑，比如更新 UI、清理资源或者同步其他操作的开始。这对于创建响应式和用户友好的应用程序非常有用。

6. 取消操作的处理机制

6.1 取消操作的基本方法

6.1.1 如何正确地取消单个或多个NSOperation

在iOS开发中，管理好多线程操作的生命周期是至关重要的，尤其是涉及到取消操作时。NSOperation 提供了一个非常直接的方式来取消一个操作，即设置其 cancel 属性为 YES 。

NSOperation *operation = ...; // 获取或创建一个NSOperation实例
[operation cancel];

当调用 cancel 方法后，操作对象会进入 isCancelled 状态。你需要在操作执行的代码中定期检查这个状态，以便在操作被取消时正确地终止。

- (void)main {
    while (!self.isCancelled && !self.isFinished) {
        // 执行任务代码
    }
    if (self.isCancelled) {
        // 执行取消时的清理操作
    }
}

在上述代码中，我们通过一个循环来检查操作是否被取消。一旦检测到取消请求，就可以跳出循环并执行必要的清理工作。

6.1.2 取消操作的条件和时机选择

取消操作的时机和条件需要开发者根据应用的需求来设计。通常情况下，取消操作发生在用户中断操作（如按返回键、刷新页面等），或者程序内部发现某些异常情况不再需要继续执行当前操作。

// 示例：在按钮点击事件中取消操作
- (IBAction)cancelOperation:(id)sender {
    [operation cancel];
    [operation waitUntilFinished]; // 等待操作取消完成
}

在上述示例中，我们在用户点击取消按钮时立即调用 cancel 方法，并等待操作真正完成。需要注意的是， waitUntilFinished 方法可能造成线程阻塞，因此在复杂的多线程应用中需要谨慎使用。

6.2 处理取消操作的影响

6.2.1 取消操作对依赖和线程安全的影响

取消操作可能会导致依赖于该操作的其他操作出现问题。NSOperation 的设计允许依赖于取消操作的其他操作被自动取消。然而，开发者需要明确地处理这种情况以防止潜在的资源泄露或数据不一致。

// 依赖操作在被取消时的处理
- (void)cancelDependencies {
    for (NSOperation *dependency in [self dependencies]) {
        if ([dependency isCancelled]) {
            [dependency finish];
        }
    }
}

在上述代码段中，我们遍历所有依赖的操作并检查它们是否被取消。如果是，我们调用 finish 方法来结束依赖操作。

线程安全是处理取消操作时另一个需要考虑的问题。确保在取消过程中访问的任何共享资源都得到正确的同步保护，防止在取消瞬间产生竞争条件。

// 线程安全的取消操作示例
- (void)cancelThreadSafe {
    @synchronized(self) {
        if (!self.isCancelled) {
            // 执行线程安全的取消操作
        }
    }
}

在这个例子中，我们使用 @synchronized 块来保证操作的线程安全性。这样可以防止多线程环境下对共享资源的并发访问。

6.2.2 清理资源和确保数据一致性的策略

在操作被取消后，正确的清理资源和保持数据一致性是非常重要的。这包括释放内存、关闭文件句柄、通知其他部分的操作不要使用已经取消操作产生的数据等。

// 清理资源和保持数据一致性的策略
- (void)cleanupResources {
    // 释放已分配的资源
    freeResources();

    // 通知其他操作不要使用本操作产生的数据
    notifyOthers();

    // 确保取消操作的线程安全
    [self cancelThreadSafe];
}

在上述示例中，我们定义了一个方法来封装资源清理和数据一致性保持的逻辑。这确保了无论何时取消操作，都能采取适当的措施来处理其影响。

通过这些策略的实施，可以确保应用程序在执行复杂多线程操作时的稳定性和可靠性。

7. NSBlockOperation的使用与代码结构简化

7.1 NSBlockOperation的特性与优势

7.1.1 NSBlockOperation简介及其用法

NSBlockOperation 是NSOperation的一个子类，它允许开发者将一个或多个代码块（blocks）封装为一个操作。这种设计可以极大地简化代码结构，使并发编程更加直观。其主要优势在于它能并行执行多个代码块，而无需手动处理线程的创建与管理。

使用 NSBlockOperation 的步骤通常包括初始化对象、添加代码块，然后启动操作。例如：

NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
    // 第一个代码块的执行内容
}];

// 添加更多代码块
[blockOperation addExecutionBlock:^{
    // 第二个代码块的执行内容
}];

// 执行操作
[blockOperation start];

7.1.2 NSBlockOperation与其他NSOperation的对比

NSBlockOperation 与传统的 NSOperation 或者 NSOperationQueue 相比，其优势在于代码块的简洁性和易用性。它特别适合于那些易于并行执行且相互之间没有依赖的任务。与 NSOperationQueue 相比， NSBlockOperation 更适合简单的并行任务，而 NSOperationQueue 提供了更多的灵活性和控制能力，例如任务依赖管理、操作取消、以及队列中的线程管理等。

7.2 代码结构简化实践

7.2.1 利用NSBlockOperation简化代码结构

在实际的iOS开发项目中，可以利用 NSBlockOperation 的并行执行特性来简化一些复杂的操作。例如，如果需要从多个网络源下载数据，可以使用 NSBlockOperation 将每个下载任务作为一个独立的代码块，并行执行。

NSBlockOperation *downloadOperation = [NSBlockOperation blockOperationWithBlock:^{
    NSURL *url1 = [NSURL URLWithString:@"***"];
    [self downloadDataFromURL:url1];
}];

[downloadOperation addExecutionBlock:^{
    NSURL *url2 = [NSURL URLWithString:@"***"];
    [self downloadDataFromURL:url2];
}];

[downloadOperation addExecutionBlock:^{
    NSURL *url3 = [NSURL URLWithString:@"***"];
    [self downloadDataFromURL:url3];
}];

[downloadOperation start];

7.2.2 实现复杂操作的代码示例与解析

下面是一个更加复杂的例子，它演示了如何在下载任务完成后处理数据，并且使用了完成处理器来进一步简化代码结构。

NSBlockOperation *complexOperation = [NSBlockOperation blockOperationWithBlock:^{
    // 并行执行多个任务
}];

[complexOperation addExecutionBlock:^{
    // 任务1
}];

[complexOperation addExecutionBlock:^{
    // 任务2
}];

[complexOperation addCompletionBlock:^{
    // 所有任务执行完毕后的操作
    // 这里可以处理所有任务的结果
}];

// 启动操作
[complexOperation start];

在这个例子中， addCompletionBlock: 方法允许我们在所有并行的代码块执行完毕后执行特定的操作。这使得整个任务的逻辑更加清晰，并且将成功处理和错误处理的代码与任务执行代码分离开来。简化了代码结构的同时，还增强了程序的可维护性和可读性。

通过 NSBlockOperation ，开发者可以更专注于业务逻辑的实现，而不是底层的线程管理和任务协调。这使得并发编程更加高效，并能够显著提高iOS应用的响应性和性能。

本文还有配套的精品资源，点击获取