iOS学习-多线程

2023-03-31  本文已影响0人  麻辣香锅加特辣

iOS开发中，多线程编程是非常重要的一部分。它可以帮助我们更好地利用CPU、提高应用程序的响应速度以及避免阻塞主线程。iOS常见的多线程编程工具有NSThread、GCD和NSOperationQueue。本文将介绍这三个工具的原理、区别、线程安全以及使用中需要注意的问题。

一、NSThread

原理

NSThread 是 Foundation 框架提供的一个轻量级多线程方案，是基于POSIX线程（Pthreads）实现的，可以用来手动创建和管理线程，每个 NSThread 实例代表一个线程。

NSThread 的工作流程如下：

  1. 手动创建 NSThread 实例
  2. 为 NSThread 对象指定 selector，该 selector 代表该线程要执行的任务
  3. 启动线程（调用 start 方法）
  4. NSThread 会调用 selector 执行任务，任务执行完成后线程自动退出

NSThread 相对于 GCD 和 NSOperationQueue 来说，是一种较为底层的多线程方案。使用 NSThread 需要手动管理线程的生命周期、锁等，因此编写的代码比较冗长，适用于对线程细节要求较高的场合。

代码示例

下面是一个简单的使用 NSThread 的示例，该示例创建一个新的线程来执行任务：

- (void)startThread {
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
    [thread start];
}

- (void)run {
    NSLog(@"start thread");
    // 执行任务
    NSLog(@"end thread");
    [NSThread exit];
}

二、GCD(Grand Central Dispatch)

原理

GCD是苹果公司推出的一种多线程技术，用于管理应用程序中的并发任务。GCD使用的核心是线程池，这是一个由操作系统内部维护的线程池，应用程序可以向其中提交任务，由GCD自动分配线程来执行任务，从而达到提高程序并发能力和性能的目的。

GCD有两个基本概念：任务和队列。
任务：需要执行的操作，可以是一个函数、一个方法等等。
队列：任务的容器，用于存储要执行的任务。GCD中有两种队列：串行队列和并发队列。

GCD队列：串行队列和并发队列。
串行队列：每次只有一个任务被执行，任务按照队列的先进先出的原则依次执行。
并发队列：可以同时执行多个任务，任务的执行顺序是不确定的。

GCD任务：同步任务和异步任务。
同步任务：在当前线程中执行，任务完成后才能继续执行后面的代码。
异步任务：在其他线程中执行，任务提交后就立即返回，不会等待任务完成。

GCD还提供了dispatch group的概念，可以将一组任务放到一个组里进行处理，组里的所有任务执行完成后，可以执行另外一个任务。这个功能在需要进行多个任务并发执行，但是需要等待所有任务完成后再进行下一步操作的场景中非常有用。

GCD也支持信号量(semaphore)的概念，可以控制并发任务数量。通过控制信号量的值，可以让指定数量的任务同时执行，避免系统资源过度占用。

信号量有两个基本操作：
signal: 用于增加信号量的值；
wait: 用于等待信号量的值，如果信号量的值为 0，则等待，直到信号量的值大于 0，然后将信号量的值减 1。

GCD优点
简单易用：GCD使用简单，代码易读易懂。
自动管理线程池：GCD能够自动管理线程池，减少线程创建和销毁的开销。
精细的任务调度：GCD提供了多种队列和任务类型，能够满足各种场景的需求。

GCD使用注意事项

示例代码：

dispatch_async(dispatch_get_main_queue(), ^{
    // 在主线程中执行代码
});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 在子线程中执行代码
});

dispatch_queue_t serialQueue = dispatch_queue_create("com.example.serialQueue", NULL);
dispatch_async(serialQueue, ^{
    // 任务 1
});
dispatch_async(serialQueue, ^{
    // 任务 2
});

dispatch_queue_t concurrentQueue = dispatch_queue_create("com.example.concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(concurrentQueue, ^{
    // 任务 1
});
dispatch_async(concurrentQueue, ^{
    // 任务 2
});

dispatch_queue_attr_t attr = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, QOS_CLASS_DEFAULT, 0);
dispatch_queue_t customQueue = dispatch_queue_create("customQueue", attr);
dispatch_async(customQueue, ^{
    // 任务 1
});
dispatch_async(customQueue, ^{
    // 任务 2
});

dispatch_group_t group = dispatch_group_create();

dispatch_group_enter(group);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 异步执行任务1
    dispatch_group_leave(group);
});

dispatch_group_enter(group);
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 异步执行任务2
    dispatch_group_leave(group);
});

dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    // 所有任务完成后执行的操作
    NSLog(@"All tasks completed");
});

dispatch_group_t group = dispatch_group_create();

dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 异步执行任务1
});

dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 异步执行任务2
});

dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    // 所有任务完成后执行的操作
    NSLog(@"All tasks completed");
});

dispatch_group_t group = dispatch_group_create();

dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 异步执行任务1
});

dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 异步执行任务2
});

// 阻塞当前线程等待异步任务完成
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

// 所有任务完成后执行的操作
NSLog(@"All tasks completed");

// 创建一个信号量，初始值为 0
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

// 创建一个并行队列
dispatch_queue_t queue = dispatch_queue_create("com.example.semaphore", DISPATCH_QUEUE_CONCURRENT);

// 在队列中执行异步任务，任务完成后 signal 信号量
dispatch_async(queue, ^{
    // 执行异步任务
    // ...

    // signal 信号量，让另一个线程可以继续执行
    dispatch_semaphore_signal(semaphore);
});

// 等待信号量，直到信号量的值大于 0
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

// 另一个线程执行完后继续执行这里的代码
// ...

注意，在使用 GCD 时，应该避免在主队列中执行耗时的操作，否则会导致 UI 卡顿。

三、NSOperationQueue

原理

NSOperationQueue 是一种基于 GCD 封装的 Objective-C 对象，它可以管理和调度任务。NSOperation 是抽象的操作类，它提供了更多的控制选项，可以通过继承 NSOperation 来编写自定义操作类。

NSOperationQueue 支持两种类型的队列：主队列和自定义队列。主队列在主线程上执行，自定义队列在后台线程上执行。NSOperationQueue 会在后台线程上并发执行队列中的操作，并控制队列中的操作的最大并发数。

NSOperationQueue 与 GCD 相比，其最大的优势在于它更加面向对象，提供了更多的控制选项。

使用示例：

NSOperationQueue *queue = [[NSOperationQueue alloc] init];

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
    // 在这里执行任务
}];

[queue addOperation:operation];

queue.maxConcurrentOperationCount = 2;

blockOperationWithBlock:^{
    // 在这里执行任务1
}];

NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
    // 在这里执行任务2
}];

// 设置依赖关系，让任务2 在任务1 完成后执行
[operation2 addDependency:operation1];

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

// 暂停队列
[queue setSuspended:YES];

// 继续队列
[queue setSuspended:NO];

// 取消队列中所有任务
[queue cancelAllOperations];

NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
    // 在这里执行任务1
}];

NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
    // 在这里执行任务2
}];

[operation1 setQueuePriority:NSOperationQueuePriorityHigh];
[operation2 setQueuePriority:NSOperationQueuePriorityLow];

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

NSOperationQueue是线程安全的。多个线程可以同时向同一个NSOperationQueue中添加任务，NSOperationQueue内部会自动管理这些任务的执行顺序和线程管理，可以根据系统资源情况、队列中的任务数量和优先级等因素来动态调整线程数量。这使得使用NSOperationQueue时，无需手动管理线程，只需将任务添加到队列中即可。
但是需要注意在操作共享资源时，还是需要考虑线程安全问题，比如加锁等机制。

综上所述，NSThread、GCD和NSOperationQueue都是iOS多线程编程中常用的工具，每种工具都有自己的优势和适用场景。了解它们的原理、区别和使用注意事项，能够帮助我们更好地利用多线程提升应用的性能和用户体验。

上一篇下一篇

猜你喜欢

热点阅读