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

Objective-C 多线程编程原理与实现

2022-04-287.9k 阅读

多线程基础概念

在深入探讨 Objective-C 的多线程编程之前，我们先来了解一些多线程的基础概念。

线程与进程

进程是程序的一次执行过程，它是一个动态的概念。每个进程都有自己独立的内存空间，包含了代码、数据和进程控制块等信息。例如，当我们在 Mac 上打开一个 Safari 浏览器应用，这就是一个进程，它有自己独立的内存来存储网页数据、渲染结果等。

而线程则是进程中的一个执行单元，一个进程可以包含多个线程。线程共享进程的内存空间，它们可以并发执行不同的任务。比如在 Safari 浏览器进程中，可能有一个线程负责加载网页资源，另一个线程负责渲染页面，还有线程负责处理用户的交互操作。

并发与并行

并发是指在一段时间内，系统可以处理多个任务，但实际上在某个瞬间，只有一个任务在执行。操作系统通过快速切换线程，让用户感觉多个任务在同时进行。这就好比一个人同时处理多项任务，一会儿做这个，一会儿做那个，但同一时刻只能专注于一项任务。

并行则是指在同一时刻，有多个任务在不同的处理器核心上真正地同时执行。例如，一个多核 CPU 可以同时运行多个线程，每个核心执行一个线程，实现真正的并行处理。

多线程的优势与挑战

多线程编程有很多优势。首先，它可以提高程序的响应性。比如在一个图形界面应用中，如果所有任务都在主线程执行，当执行一个耗时操作（如文件读取或网络请求）时，界面会卡死，用户无法进行任何操作。而使用多线程，将耗时操作放在子线程执行，主线程可以继续响应用户的交互，提升用户体验。

其次，多线程可以充分利用多核处理器的性能，提高程序的执行效率。对于一些计算密集型任务，将其拆分成多个子任务在不同线程并行执行，可以大大缩短任务的执行时间。

然而，多线程编程也带来了一些挑战。其中最主要的就是线程安全问题。由于多个线程共享进程的内存空间，当多个线程同时访问和修改共享数据时，可能会导致数据不一致的情况。例如，一个线程正在读取一个变量的值，而另一个线程同时修改了这个变量，就可能导致读取到的数据不正确。此外，死锁也是多线程编程中常见的问题，当两个或多个线程相互等待对方释放资源时，就会形成死锁，导致程序无法继续执行。

Objective-C 中的多线程编程方式

Objective-C 提供了多种多线程编程方式，每种方式都有其特点和适用场景。

NSThread

NSThread 是 Objective-C 中最基础的多线程类，它允许我们直接创建和管理线程。使用 NSThread 创建线程非常简单，以下是一个简单的示例：

// 创建一个新线程
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(myThreadMethod) object:nil];
// 启动线程
[thread start];

// 线程执行的方法
- (void)myThreadMethod {
    NSLog(@"This is a new thread with name: %@", [NSThread currentThread].name);
}

在上述代码中，我们通过 initWithTarget:selector:object: 方法创建了一个新线程，指定了线程要执行的方法 myThreadMethod。然后调用 start 方法启动线程。

NSThread 的优点是简单直接，对线程的控制粒度较高。我们可以直接设置线程的优先级、名称等属性。例如：

thread.name = @"MyCustomThread";
thread.threadPriority = 0.5; // 线程优先级，范围是 0.0（最低）到 1.0（最高）

然而，NSThread 也有一些缺点。它需要手动管理线程的生命周期，包括创建、启动、暂停、终止等操作。而且，NSThread 没有提供线程同步机制，需要开发者自己实现，这增加了编程的复杂度。

NSOperationQueue 与 NSOperation

NSOperationQueue 和 NSOperation 提供了一种更高级的多线程编程方式。NSOperation 是一个抽象类，它代表一个异步任务。我们通常使用它的子类 NSInvocationOperation 或 NSBlockOperation，或者自定义一个继承自 NSOperation 的子类来实现具体的任务。

NSOperationQueue 是一个操作队列，它负责管理和执行 NSOperation。以下是使用 NSBlockOperation 和 NSOperationQueue 的示例：

// 创建一个操作队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];

// 创建一个 NSBlockOperation
NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"This is an operation in the queue");
}];

// 将操作添加到队列中
[queue addOperation:operation];

在上述代码中，我们首先创建了一个操作队列 queue，然后创建了一个 NSBlockOperation，并将其添加到队列中。队列会自动在后台线程中执行这个操作。

NSInvocationOperation 的使用方式类似，不过它是基于方法调用的。例如：

// 定义一个方法
- (void)myInvocationMethod {
    NSLog(@"This is an invocation operation");
}

// 创建一个 NSInvocationOperation
NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(myInvocationMethod) object:nil];

// 将操作添加到队列中
[queue addOperation:invocationOperation];

如果需要自定义 NSOperation，我们可以继承 NSOperation 并实现 main 方法，这个方法就是操作执行的代码。例如：

@interface MyCustomOperation : NSOperation
@end

@implementation MyCustomOperation
- (void)main {
    if (!self.isCancelled) {
        NSLog(@"This is a custom operation");
    }
}
@end

// 使用自定义操作
MyCustomOperation *customOperation = [[MyCustomOperation alloc] init];
[queue addOperation:customOperation];

NSOperationQueue 和 NSOperation 的优点是提供了更灵活和高层次的任务管理。我们可以设置操作之间的依赖关系，例如：

NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"Operation 1");
}];

NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"Operation 2");
}];

// 设置 operation2 依赖于 operation1
[operation2 addDependency:operation1];

[queue addOperation:operation1];
[queue addOperation:operation2];

在上述代码中，operation2 会在 operation1 完成后才开始执行。此外，NSOperationQueue 还支持设置最大并发数，控制同时执行的操作数量。

queue.maxConcurrentOperationCount = 3; // 设置最大并发数为 3

Grand Central Dispatch (GCD)

Grand Central Dispatch（GCD）是 Apple 开发的一种基于队列的高效多线程编程模型。它提供了一种更简洁、更高效的异步编程方式。

GCD 中有两种类型的队列：串行队列和并发队列。系统提供了几个全局并发队列，我们可以通过 dispatch_get_global_queue 函数获取。例如：

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

这里 DISPATCH_QUEUE_PRIORITY_DEFAULT 表示默认优先级，还有 DISPATCH_QUEUE_PRIORITY_HIGH、DISPATCH_QUEUE_PRIORITY_LOW 和 DISPATCH_QUEUE_PRIORITY_BACKGROUND 等优先级可供选择。

我们也可以创建自己的串行队列，使用 dispatch_queue_create 函数：

dispatch_queue_t serialQueue = dispatch_queue_create("com.example.serialQueue", DISPATCH_QUEUE_SERIAL);

创建好队列后，我们可以使用 dispatch_async 函数将任务异步提交到队列中执行。例如：

dispatch_async(globalQueue, ^{
    NSLog(@"This task is executed asynchronously in a global concurrent queue");
});

dispatch_async(serialQueue, ^{
    NSLog(@"This task is executed asynchronously in a serial queue");
});

除了异步提交任务，GCD 还提供了 dispatch_sync 函数用于同步提交任务。同步提交的任务会阻塞当前线程，直到任务执行完成。例如：

dispatch_sync(serialQueue, ^{
    NSLog(@"This task is executed synchronously in a serial queue");
});
NSLog(@"After synchronous task");

在上述代码中，NSLog(@"After synchronous task") 会在同步任务执行完成后才输出。

GCD 还支持一些高级特性，比如 dispatch group。我们可以使用 dispatch group 来等待一组任务全部完成。例如：

dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_group_async(group, queue, ^{
    NSLog(@"Task 1");
});

dispatch_group_async(group, queue, ^{
    NSLog(@"Task 2");
});

dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    NSLog(@"All tasks are completed");
});

在上述代码中，dispatch_group_notify 会在 group 中的所有任务（这里是 Task 1 和 Task 2）完成后，在主线程中执行回调块。

线程同步与锁机制

在多线程编程中，线程同步是非常重要的，因为多个线程可能同时访问和修改共享资源，这可能导致数据不一致等问题。Objective-C 提供了多种线程同步机制，主要包括锁、信号量和条件变量等。

锁

锁是最常用的线程同步工具。在 Objective-C 中，我们可以使用 NSLock、NSRecursiveLock、NSConditionLock 等类来实现锁机制。

NSLock 是最基本的锁，它提供了简单的加锁和解锁操作。例如：

NSLock *lock = [[NSLock alloc] init];

// 加锁
[lock lock];
// 访问共享资源
//...
// 解锁
[lock unlock];

NSRecursiveLock 是一种递归锁，同一个线程可以多次加锁而不会造成死锁。每次加锁后，必须有相同次数的解锁操作。例如：

NSRecursiveLock *recursiveLock = [[NSRecursiveLock alloc] init];

- (void)recursiveMethod {
    [recursiveLock lock];
    // 访问共享资源
    //...
    [self recursiveMethod];
    [recursiveLock unlock];
}

NSConditionLock 是一种条件锁，它允许我们根据特定条件来加锁。例如：

NSConditionLock *conditionLock = [[NSConditionLock alloc] initWithCondition:1];

// 等待条件为 2 时加锁
[conditionLock lockWhenCondition:2];
// 访问共享资源
//...
[conditionLock unlock];

信号量

信号量（dispatch_semaphore）是 GCD 提供的一种线程同步机制。它可以控制同时访问共享资源的线程数量。例如，我们创建一个信号量，初始值为 1，就可以将其当作互斥锁使用。

dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

// 等待信号量
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
// 访问共享资源
//...
// 释放信号量
dispatch_semaphore_signal(semaphore);

如果我们将信号量的初始值设置为大于 1，比如设置为 3，那么最多可以有 3 个线程同时访问共享资源。

条件变量

条件变量（NSCondition）结合了锁和条件判断的功能。它允许线程在满足特定条件时才继续执行。例如：

NSCondition *condition = [[NSCondition alloc] init];
BOOL dataReady = NO;

// 线程 1
- (void)producer {
    [condition lock];
    // 生产数据
    dataReady = YES;
    [condition signal]; // 通知等待的线程
    [condition unlock];
}

// 线程 2
- (void)consumer {
    [condition lock];
    while (!dataReady) {
        [condition wait]; // 等待数据准备好
    }
    // 消费数据
    [condition unlock];
}

在上述代码中，consumer 线程会在 dataReady 为 NO 时等待，直到 producer 线程设置 dataReady 为 YES 并发送信号通知。

多线程编程中的常见问题与解决方法

在多线程编程过程中，会遇到一些常见的问题，需要我们掌握相应的解决方法。

死锁

死锁是多线程编程中最常见的问题之一。当两个或多个线程相互等待对方释放资源时，就会形成死锁，导致程序无法继续执行。例如：

NSLock *lock1 = [[NSLock alloc] init];
NSLock *lock2 = [[NSLock alloc] init];

// 线程 1
- (void)thread1 {
    [lock1 lock];
    [lock2 lock];
    // 访问共享资源
    [lock2 unlock];
    [lock1 unlock];
}

// 线程 2
- (void)thread2 {
    [lock2 lock];
    [lock1 lock];
    // 访问共享资源
    [lock1 unlock];
    [lock2 unlock];
}

在上述代码中，如果 thread1 先获取了 lock1，同时 thread2 先获取了 lock2，然后它们分别尝试获取对方持有的锁，就会形成死锁。

解决死锁的方法主要有以下几种：

  1. 避免嵌套锁：尽量减少锁的嵌套使用，如果必须使用，确保所有线程以相同的顺序获取锁。
  2. 使用超时机制：在获取锁时设置一个超时时间，如果在规定时间内无法获取锁，则放弃并尝试其他操作。例如，NSLock 类提供了 tryLock 方法，它会尝试获取锁，如果获取失败立即返回 NO。
  3. 使用资源分配图算法：这是一种更复杂的方法，通过分析线程对资源的请求和持有关系，检测是否存在死锁，并采取相应的解除措施。

数据竞争

数据竞争是指多个线程同时访问和修改共享数据，导致数据不一致的问题。例如：

int sharedValue = 0;

// 线程 1
- (void)thread1 {
    for (int i = 0; i < 1000; i++) {
        sharedValue++;
    }
}

// 线程 2
- (void)thread2 {
    for (int i = 0; i < 1000; i++) {
        sharedValue--;
    }
}

在上述代码中，thread1 和 thread2 同时对 sharedValue 进行加 1 和减 1 操作，由于多线程的不确定性，最终 sharedValue 的值可能不是预期的 0。

解决数据竞争的方法就是使用线程同步机制，如前面介绍的锁、信号量等。例如，使用 NSLock 来保护 sharedValue：

NSLock *lock = [[NSLock alloc] init];
int sharedValue = 0;

// 线程 1
- (void)thread1 {
    for (int i = 0; i < 1000; i++) {
        [lock lock];
        sharedValue++;
        [lock unlock];
    }
}

// 线程 2
- (void)thread2 {
    for (int i = 0; i < 1000; i++) {
        [lock lock];
        sharedValue--;
        [lock unlock];
    }
}

通过加锁，确保在同一时刻只有一个线程可以访问和修改 sharedValue，从而避免数据竞争问题。

线程饥饿

线程饥饿是指某个线程长时间无法获取执行机会，因为其他线程总是优先获取资源。例如，当一个高优先级线程持续占用资源时，低优先级线程可能会饿死。

解决线程饥饿的方法包括：

  1. 调整线程优先级：合理设置线程的优先级，避免某个线程优先级过高导致其他线程无法执行。在 NSThread 中可以通过 threadPriority 属性设置线程优先级，在 GCD 中可以通过设置队列优先级来间接影响任务的执行优先级。
  2. 公平调度：一些操作系统或编程模型提供了公平调度算法，确保每个线程都有机会执行。例如，某些操作系统的调度器会根据线程的等待时间等因素来分配执行时间，避免线程饥饿。

多线程编程在实际项目中的应用场景

多线程编程在实际项目中有很多应用场景，下面介绍几个常见的场景。

网络请求

在移动应用开发中，网络请求是非常常见的操作。由于网络请求通常是耗时操作，如果在主线程执行，会导致界面卡顿，影响用户体验。因此，我们通常将网络请求放在子线程中执行。

使用 GCD 进行网络请求非常方便，例如：

dispatch_queue_t networkQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_async(networkQueue, ^{
    NSURL *url = [NSURL URLWithString:@"https://example.com/api/data"];
    NSData *data = [NSData dataWithContentsOfURL:url];
    // 处理网络响应数据
    dispatch_async(dispatch_get_main_queue(), ^{
        // 更新 UI 等操作
    });
});

在上述代码中，我们将网络请求放在全局并发队列 networkQueue 中执行，当网络请求完成后，再将处理 UI 更新等操作放在主线程执行，这样可以保证界面的流畅性。

数据处理与计算

对于一些数据处理和计算密集型任务，如图片处理、视频编码等，使用多线程可以充分利用多核处理器的性能，提高处理速度。

例如，在进行图片缩放处理时，可以将图片分成多个部分，每个部分在不同线程中进行缩放，最后再合并结果。使用 NSOperationQueue 可以很方便地实现这种任务划分：

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
queue.maxConcurrentOperationCount = 4; // 根据处理器核心数设置并发数

// 将图片分成 4 个部分，每个部分创建一个操作
for (int i = 0; i < 4; i++) {
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
        // 对图片的第 i 部分进行缩放处理
    }];
    [queue addOperation:operation];
}

// 所有部分处理完成后，合并结果
[queue addOperationWithBlock:^{
    // 合并图片缩放后的部分
}];

动画与渲染

在游戏开发或一些动画效果较多的应用中，动画与渲染也可以利用多线程来提高性能。例如，在一个 3D 游戏中，可以将模型渲染、动画计算等任务放在不同线程中执行，主线程则负责处理用户输入和更新显示。

使用 NSThread 可以实现简单的动画渲染线程：

// 创建动画渲染线程
NSThread *renderThread = [[NSThread alloc] initWithTarget:self selector:@selector(renderAnimation) object:nil];
[renderThread start];

// 动画渲染方法
- (void)renderAnimation {
    while (true) {
        // 进行动画渲染计算
        // 更新渲染结果
        usleep(16667); // 控制帧率，约 60 帧/秒
    }
}

通过将动画渲染放在单独的线程中执行，可以避免主线程的卡顿，提供更流畅的动画效果。

多线程编程的性能优化

在多线程编程中，性能优化是非常重要的，以下是一些常见的性能优化方法。

减少锁的使用

锁虽然是线程同步的重要工具，但它也会带来性能开销。因为加锁和解锁操作会涉及到上下文切换等操作。所以，在保证线程安全的前提下，尽量减少锁的使用。

例如，对于一些只读操作，可以不加锁。如果必须加锁，尽量缩小锁的保护范围，只在对共享资源进行写操作时加锁。

合理设置线程数量

线程数量并非越多越好。过多的线程会导致线程上下文切换频繁，消耗大量的系统资源，反而降低性能。一般来说，线程数量应该根据任务类型和处理器核心数来合理设置。

对于计算密集型任务，线程数量可以设置为处理器核心数或略小于核心数，以避免过多的上下文切换。对于 I/O 密集型任务，由于线程在等待 I/O 操作时会处于空闲状态，可以适当增加线程数量，充分利用处理器资源。

使用无锁数据结构

在某些情况下，使用无锁数据结构可以避免锁带来的性能开销。例如，在一些多线程环境下的计数器操作，可以使用原子变量（如 OSAtomicIncrement32 等）来实现无锁的计数，提高性能。

#import <libkern/OSAtomic.h>

// 定义一个原子计数器
volatile int32_t counter = 0;

// 线程 1
- (void)thread1 {
    for (int i = 0; i < 1000; i++) {
        OSAtomicIncrement32(&counter);
    }
}

// 线程 2
- (void)thread2 {
    for (int i = 0; i < 1000; i++) {
        OSAtomicIncrement32(&counter);
    }
}

在上述代码中，OSAtomicIncrement32 函数可以在多线程环境下无锁地对 counter 进行原子加 1 操作，避免了使用锁带来的性能开销。

缓存线程局部数据

如果某个线程需要频繁访问一些数据，可以将这些数据缓存在线程局部变量中，减少对共享数据的访问次数。这样不仅可以提高性能，还可以减少锁的竞争。

例如，在一个多线程处理日志的场景中，每个线程可以维护自己的日志缓冲区，将日志信息先写入缓冲区，然后定期将缓冲区的数据写入共享的日志文件。这样可以减少对日志文件的频繁写入操作，提高整体性能。

总结与展望

多线程编程是 Objective-C 开发中非常重要的一部分，它可以提高程序的响应性、利用多核处理器性能，但同时也带来了线程安全、死锁等问题。通过掌握 NSThread、NSOperationQueue、GCD 等多线程编程方式，以及锁、信号量等线程同步机制，我们可以有效地进行多线程编程，并解决常见的问题。

在未来，随着硬件技术的不断发展，多核处理器的性能将越来越强大，多线程编程的重要性也将日益凸显。同时，新的编程模型和框架可能会不断涌现，为多线程编程提供更高效、更简洁的方式。作为开发者，我们需要不断学习和掌握新的技术，以适应不断变化的开发需求。希望本文介绍的内容能对大家在 Objective-C 多线程编程方面有所帮助，让我们能够编写出更高效、更稳定的应用程序。