一.概述
1.基本概念
同步与异步的概念
- 同步 必须等待当前语句执行完毕，才可以执行下一个语句。
- 异步 不用等待当前语句执行完毕，就可以执行下一个语句。
进程与线程的概念
-
进程
- 概念：系统中正在运行的应用程序。
- 特点：每个进程都运行在其专用且受保护的内存空间，不同的进程之间相互独立，互不干扰。
-
线程
- 概念：一个进程要想执行任务，必须得有线程 (每一个进程至少要有一条线程) 线程是进程的基本执行单元，一个进程的所有任务都是在线程中执行的。
- 特点：一条线程在执行任务的时候是串行(按顺序执行)的。如果要让一条线程执行多个任务，那么只能一个一个地按顺序执行这些任务。也就是说，在同一时间，一条线程只能执行一个任务
多线程的概念与原理
- 概念：1个进程可以开启多条线程，多条线程可以并发（同时）执行不同的任务。
- 原理：同一时间，CPU只能处理一条线程，即只有一条线程在工作多线程同时执行，其实是CPU快速地在多条线程之间进行切换。如果CPU调度线程的速度足够快，就会造成多线程并发执行的”假象”。
多线程的优缺点
-
优点
- 能适当提高程序的执行效率。
- 能适当提高资源的利用率(CPU、内存利用率)
-
缺点
- 开启线程需要占用一定的内存空间（默认情况下，每一条线程都占用512KB），如果开启大量的线程，会占用大量的内存空间，从而降低程序的性能。
- 线程越多，CPU在调度线程上的开销就越大。
- 线程越多，程序设计就会更复杂：比如 线程间通讯、多线程的数据共享等。
总结
实际上，使用多线程，由于会开线程，必然就会消耗性能，但是却可以提高用户体验。所以，综合考虑，在保证良好的用户体验的前提下，可以适当地开线程，一般开3-6条。
在iOS中每个进程启动后都会建立一个主线程（UI线程），这个线程是其他线程的父线程。由于在iOS中除了主线程，其他子线程是独立于Cocoa Touch的，所以只有主线程可以更新UI界面。iOS中多线程使用并不复杂，关键是如何控制好各个线程的执行顺序、处理好资源竞争问题。
iOS常见多线程方案
二.iOS常见多线程使用方法
1. Pthreads
pthread 是一套通用的多线程的 API，可以在Unix / Linux / Windows 等系统跨平台使用，使用 C 语言编写，需要程序员自己管理线程的生命周期，使用难度较大，我们在 iOS 开发中几乎不使用 pthread，但是还是来可以了解一下的。
1.1 使用方法
- 首先要包含头文件#import <pthread.h>
- 其次要创建线程，并开启线程执行任务
// 1. 创建线程: 定义一个pthread_t类型变量
pthread_t thread;
// 2. 开启线程: 执行任务
/*
第一个参数&thread是线程对象，指向线程标识符的指针
第二个是线程属性，可赋值NULL
第三个run表示指向函数的指针(run对应函数里是需要在新线程中执行的任务)
第四个是运行函数的参数，可赋值NULL
*/
pthread_create(&thread, NULL, run, NULL);
// 3. 设置子线程的状态设置为 detached，该线程运行结束后会自动释放所有资源
pthread_detach(thread);
void * run(void *param) // 新线程调用方法，里边为需要执行的任务
{
NSLog(@"%@", [NSThread currentThread]);
return NULL;
}
1.2 pthread其它方法
* pthread_create() 创建一个线程
* pthread_exit() 终止当前线程
* pthread_cancel() 中断另外一个线程的运行
* pthread_join() 阻塞当前的线程，直到另外一个线程运行结束
* pthread_attr_init() 初始化线程的属性
* pthread_attr_setdetachstate() 设置脱离状态的属性（决定这个线程在终止时是否可以被结合）
* pthread_attr_getdetachstate() 获取脱离状态的属性
* pthread_attr_destroy() 删除线程的属性
* pthread_kill() 向指定的线程发送信号
2. NSThread
NSThread 是苹果官方提供的，使用起来比 pthread 更加面向对象，简单易用，可以直接操作线程对象。不过也需要需要程序员自己管理线程的生命周期(主要是创建)，我们在开发的过程中偶尔使用NSThread。比如我们会经常调用[NSThread currentThread]来显示当前的进程信息。
2.1 介绍
- 基于thread封装，添加面向对象概念，性能较差，偏向底层
- 相对于GCD和NSOperation来说是较轻量级的线程开发
- 使用比较简单，但是需要手动管理创建线程的生命周期、同步、异步、加锁等问题
2.2 线程初始化方法
- 先创建线程，再启动线程
// 1. 创建线程
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
// 2. 启动线程
[thread start]; // 线程一启动，就会在线程thread中执行self的run方法
// 新线程调用方法，里边为需要执行的任务
- (void)run {
NSLog(@"%@", [NSThread currentThread]);
}
- 创建线程后自动启动线程
// 1. 创建线程后自动启动线程
[NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
// 新线程调用方法，里边为需要执行的任务
- (void)run {
NSLog(@"%@", [NSThread currentThread]);
}
- 隐式创建并启动线程
// 1. 隐式创建并启动线程
[self performSelectorInBackground:@selector(run) withObject:nil];
// 新线程调用方法，里边为需要执行的任务
- (void)run {
NSLog(@"%@", [NSThread currentThread]);
}
2.3 线程其它方法
// 获得主线程
+ (NSThread *)mainThread;
// 判断是否为主线程(对象方法)
- (BOOL)isMainThread;
// 判断是否为主线程(类方法)
+ (BOOL)isMainThread;
// 获得当前线程
NSThread *current = [NSThread currentThread];
// 线程的名字——setter方法
- (void)setName:(NSString *)n;
// 线程的名字——getter方法
- (NSString *)name;
2.4 线程状态控制方法
// - 启动线程的方法
- (void)start;
// 线程进入就绪状态 -> 运行状态。当线程任务执行完毕，自动进入死亡状态
// - 阻塞（暂停）线程方法
+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;
// 线程进入阻塞状态
// - 强制停止线程
+ (void)exit;
// 线程进入死亡状态
2.5 NSThread线程之间的通信
// 在主线程上执行操作
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray<NSString *> *)array;
// equivalent to the first method with kCFRunLoopCommonModes
// 在指定线程上执行操作
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray *)array NS_AVAILABLE(10_5, 2_0);
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait NS_AVAILABLE(10_5, 2_0);
// 在当前线程上执行操作，调用 NSObject 的 performSelector:相关方法
- (id)performSelector:(SEL)aSelector;
- (id)performSelector:(SEL)aSelector withObject:(id)object;
- (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2;
2.6 线程安全
线程安全解决方案：可以给线程加锁，在一个线程执行该操作的时候，不允许其他线程进行操作。iOS 实现线程加锁有很多种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各种方式。
2.7 线程的状态转换
- 如果CPU现在调度当前线程对象，则当前线程对象进入运行状态，如果CPU调度其他线程对象，则当前线程对象回到就绪状态。
- 如果CPU在运行当前线程对象的时候调用了sleep方法\等待同步锁，则当前线程对象就进入了阻塞状态，等到sleep到时\得到同步锁，则回到就绪状态。
- 如果CPU在运行当前线程对象的时候线程任务执行完毕\异常强制退出，则当前线程对象进入死亡状态。
状态转换图
3.GCD
3.1 GCD的优点
- GCD 可用于多核的并行运算
- GCD 会自动利用更多的 CPU 内核（比如双核、四核）
- GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
- 程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码
3.2 GCD核心概念——任务和队列
任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在 GCD 中是放在 block 中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。
-
同步执行（sync）
- 同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
- 只能在当前线程中执行任务，不具备开启新线程的能力。
-
异步执行（async）
- 异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
- 可以在新的线程中执行任务，具备开启新线程的能力。
队列：这里的队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。
在 GCD 中有两种队列：串行队列和并发队列。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。
-
串行队列（Serial Dispatch Queue）
- 每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）
-
并发队列（Concurrent Dispatch Queue）
- 可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）
并发队列 的并发功能只有在异步（dispatch_async）函数下才有效。
3.3 GCD的使用步骤
- 创建一个队列（串行队列或并发队列）
- 将任务追加到任务的等待队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）
1.队列的创建方法/获取方法
- 可以使用dispatch_queue_create来创建队列，需要传入两个参数，第一个参数表示队列的唯一标识符，用于 DEBUG，可为空，Dispatch Queue 的名称推荐使用应用程序 ID 这种逆序全程域名；第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL 表示串行队列，DISPATCH_QUEUE_CONCURRENT 表示并发队列。
// 串行队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
// 并发队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
- 对于串行队列，GCD 提供了的一种特殊的串行队列：主队列（Main Dispatch Queue）。
- 所有放在主队列中的任务，都会放到主线程中执行。
- 可使用dispatch_get_main_queue()获得主队列。
// 主队列的获取方法
dispatch_queue_t queue = dispatch_get_main_queue();
- 对于并发队列，GCD 默认提供了全局并发队列（Global Dispatch Queue）。
- 可以使用dispatch_get_global_queue来获取。需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。
// 全局并发队列的获取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
全局并发队列与并发队列的区别：
- 全局并发队列与并发队列的调度方法相同
- 全局并发队列没有队列名称
- 在MRC开发中，全局并发队列不需要手动释放
2.任务的创建方法
GCD 提供了同步执行任务的创建方法dispatch_sync和异步执行任务创建方法dispatch_async。
// 同步执行任务创建方法
dispatch_sync(queue, ^{
// 这里放同步执行任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
// 这里放异步执行任务代码
});
虽然使用 GCD 只需两步，但是既然我们有两种队列（串行队列/并发队列），两种任务执行方式（同步执行/异步执行），那么我们就有了四种不同的组合方式。再加上两种特殊队列：全局并发队列、主队列。全局并发队列可以作为普通并发队列来使用。但是主队列因为有点特殊，所以我们就又多了两种组合方式。这样就有六种不同的组合方式了。
- 同步执行 + 并发队列
- 异步执行 + 并发队列
- 同步执行 + 串行队列
- 异步执行 + 串行队列
- 同步执行 + 主队列
- 异步执行 + 主队列
各种组合的结果
| 区别 | 并发队列 | 串行队列 | 主队列 |
|---|---|---|---|
| 同步(sync) | 没有开启新线程，串行执行任务 | 没有开启新线程，串行执行任务 | 没有开启新线程，串行执行任务 |
| 异步(async) | 有开启新线程，并发执行任务 | 有开启新线程(1条)，串行执行任务 | 没有开启新线程，串行执行任务 |
① 并发队列 + 同步执行
在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
/**
* 同步执行 + 并发队列
* 特点：在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
*/
- (void)syncConcurrent {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"syncConcurrent---begin");
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
});
NSLog(@"syncConcurrent---end");
}
输出结果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> syncConcurrent---begin
------> 1---<NSThread:>{number = 1, name = main}
------> 1---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> syncConcurrent---end
结论：
- 所有任务都是在当前线程（主线程）中执行的，没有开启新的线程（同步执行不具备开启新线程的能力）。
- 所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间执行的（同步任务需要等待队列的任务执行结束）。
- 任务按顺序执行的。按顺序执行的原因：虽然并发队列可以开启多个线程，并且同时执行多个任务。但是因为本身不能创建新线程，只有当前线程这一个线程（同步任务不具备开启新线程的能力），所以也就不存在并发。而且当前线程只有等待当前队列中正在执行的任务执行完毕之后，才能继续接着执行下面的操作（同步任务需要等待队列的任务执行结束）。所以任务只能一个接一个按顺序执行，不能同时被执行。
② 并发队列 + 异步执行
可以开启多个线程，任务交替（同时）执行。
/**
* 同步执行 + 并发队列
* 特点：在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
*/
/**
* 异步执行 + 并发队列
* 特点：可以开启多个线程，任务交替（同时）执行。
*/
- (void)asyncConcurrent {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"asyncConcurrent---begin");
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
});
NSLog(@"asyncConcurrent---end");
}
输出结果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> asyncConcurrent---begin
------> asyncConcurrent---end
------> 2---<NSThread:>{number = 5, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 2, name = (null)}
------> 3---<NSThread:>{number = 4, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 5, name = (null)}
结论：
- 除了当前线程（主线程），系统又开启了3个线程，并且任务是交替/同时执行的。（异步执行具备开启新线程的能力。且并发队列可开启多个线程，同时执行多个任务）。
- 所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才执行的。说明当前线程没有等待，而是直接开启了新线程，在新线程中执行任务（异步执行不做等待，可以继续执行任务）。
③ 串行队列 + 同步执行
不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
/**
* 同步执行 + 串行队列
* 特点：不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
*/
- (void)syncSerial {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"syncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
});
NSLog(@"syncSerial---end");
}
输出结果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> syncConcurrent---begin
------> 1---<NSThread:>{number = 1, name = main}
------> 1---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> syncConcurrent---end
结论：
- 所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（同步执行不具备开启新线程的能力）。
- 所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间执行（同步任务需要等待队列的任务执行结束）。
- 任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。
④ 串行队列 + 异步执行
会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务
/**
* 异步执行 + 串行队列
* 特点：会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务。
*/
- (void)asyncSerial {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"asyncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
});
NSLog(@"asyncSerial---end");
}
输出结果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> asyncConcurrent---begin
------> asyncConcurrent---end
------> 2---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
结论：
- 开启了一条新线程（异步执行具备开启新线程的能力，串行队列只开启一个线程）。
- 所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的（异步执行不会做任何等待，可以继续执行任务）。
- 任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。
- 主队列：GCD自带的一种特殊的串行队列
- 所有放在主队列中的任务，都会放到主线程中执行
- 可使用dispatch_get_main_queue()获得主队列
⑤ 主队列 + 同步执行
同步执行 + 主队列在不同线程中调用结果也是不一样，在主线程中调用会出现死锁，而在其他线程中则不会。
-
在主线程中调用
互相等待卡住锁死
/**
* 同步执行 + 主队列
* 特点(主线程调用)：互等卡主不执行。
* 特点(其他线程调用)：不会开启新线程，执行完一个任务，再执行下一个任务。
*/
- (void)syncMain {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"syncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
});
NSLog(@"syncMain---end");
}
结论：
在主线程中使用同步执行 + 主队列，追加到主线程的任务1、任务2、任务3都不再执行了，而且syncMain---end也没有打印，程序死锁了。
这是因为我们在主线程中执行syncMain方法，相当于把syncMain任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕，才会接着执行。那么当我们把任务1追加到主队列中，任务1就在等待主线程处理完syncMain任务。而syncMain任务需要等待任务1执行完毕，才能接着执行。
那么，现在的情况就是syncMain任务和任务1都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且syncMain---end也没有打印。
-
在其它线程中调用
不会开启新线程，执行完一个任务，再执行下一个任务
// 使用 NSThread 的 detachNewThreadSelector 方法会创建线程，并自动启动线程执行
selector 任务
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
输出结果：
------> currentThread---<NSThread:>{number = 3, name = (null)}
------> syncConcurrent---begin
------> 1---<NSThread:>{number = 1, name = main}
------> 1---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> syncConcurrent---end
结论：
- 所有任务都是在主线程（非当前线程）中执行的，没有开启新的线程（所有放在主队列中的任务，都会放到主线程中执行）。
- 所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间执行（同步任务需要等待队列的任务执行结束）。
- 任务是按顺序执行的（主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。
为什么现在就不会卡住了呢？
因为syncMain 任务放到了其他线程里，而任务1、任务2、任务3都在追加到主队列中，这三个任务都会在主线程中执行。syncMain 任务在其他线程中执行到追加任务1到主队列中，因为主队列现在没有正在执行的任务，所以，会直接执行主队列的任务1，等任务1执行完毕，再接着执行任务2、任务3。所以这里不会卡住线程。
⑥ 主队列 + 异步执行
只在主线程中执行任务，执行完一个任务，再执行下一个任务。
/**
* 异步执行 + 主队列
* 特点：只在主线程中执行任务，执行完一个任务，再执行下一个任务
*/
- (void)asyncMain {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"asyncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
});
NSLog(@"asyncMain---end");
}
输出结果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> asyncMain---begin
------> asyncMain---end
------> 2---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> 1---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> 1---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
结论：
- 所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（虽然异步执行具备开启线程的能力，但因为是主队列，所以所有任务都在主线程中）。
- 所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的（异步执行不会做任何等待，可以继续执行任务）。
- 任务是按顺序执行的（因为主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。
4. GCD线程间的通信
/**
* 线程间通信
*/
- (void)communication {
// 获取全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 获取主队列
dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_async(queue, ^{
// 异步追加任务
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
// 回到主线程
dispatch_async(mainQueue, ^{
// 追加在主线程中执行的任务
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
});
});
}
输出结果：
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 1, name = main}
结论：
- 可以看到在其他线程中先执行任务，执行完了之后回到主线程执行主线程的相应操作。
5. GCD的其它方法
5.1 GCD 栅栏方法：dispatch_barrier_async
我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于 栅栏 一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。
dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行。
/**
* 栅栏方法 dispatch_barrier_async
*/
- (void)barrier {
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_barrier_async(queue, ^{
// 追加任务 barrier
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"barrier---%@",[NSThread currentThread]);// 打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务4
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"4---%@",[NSThread currentThread]); // 打印当前线程
}
});
}
输出结果：
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> barrier---<NSThread:>{number = 4, name = (null)}
------> barrier---<NSThread:>{number = 4, name = (null)}
------> 4---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 4, name = (null)}
------> 4---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 4, name = (null)}
结论
- 在执行完栅栏前面的操作之后，才执行栅栏操作，最后再执行栅栏后边的操作。
5.2 GCD 延时执行方法：dispatch_after
我们经常会遇到这样的需求：在指定时间（例如3秒）之后执行某个任务。可以用 GCD 的dispatch_after函数来实现。
需要注意的是：dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。
/**
* 延时执行方法 dispatch_after
*/
- (void)after {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"asyncMain---begin");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2.0秒后异步追加任务代码到主队列，并开始执行
NSLog(@"after---%@",[NSThread currentThread]); // 打印当前线程
});
}
输出结果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> asyncMain---begin
------> after---<NSThread:>{number = 1, name = main}
结论
- 在dispatch_after相关代码执行结果中可以看出：在打印 asyncMain---begin 之后大约 2.0 秒的时间，打印了 after---<NSThread:>{number = 1, name = main}
5.3 GCD 一次性代码（只执行一次）：dispatch_once
我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了 GCD 的 dispatch_once 函数。使用
dispatch_once 函数能保证某段代码在程序运行过程中只被执行1次，并且即使在多线程的环境下，dispatch_once也可以保证线程安全。
/**
* 一次性代码（只执行一次）dispatch_once
*/
- (void)once {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});
}
5.4 GCD 快速迭代方法：dispatch_apply
通常我们会用 for 循环遍历，但是 GCD 给我们提供了快速迭代的函数dispatch_apply。dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。
我们可以利用异步队列同时遍历。比如说遍历 0~5 这6个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply可以同时遍历多个数字。
/**
* 快速迭代方法 dispatch_apply
*/
- (void)apply {
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"apply---begin");
dispatch_apply(6, queue, ^(size_t index) {
NSLog(@"%zd---%@",index, [NSThread currentThread]);
});
NSLog(@"apply---end");
}
输出结果：
------> apply---begin
------> 1---<NSThread:>{number = 3, name = (null)}
------> 0---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 3---<NSThread:>{number = 5, name = (null)}
------> 4---<NSThread:>{number = 3, name = (null)}
------> 5---<NSThread:>{number = 1, name = main}
------> apply---end
结论
- 因为是在并发队列中异步队执行任务，所以各个任务的执行时间长短不定，最后结束顺序也不定。但是apply---end一定在最后执行。这是因为dispatch_apply函数会等待全部任务执行完毕。
5.5 GCD 的队列组：dispatch_group
有时候我们会有这样的需求：分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。
- 调用队列组的 dispatch_group_async 先把任务放到队列中，然后将队列放入队列组中。或者使用队列组的 dispatch_group_enter、dispatch_group_leave 组合 来实现
dispatch_group_async。 - 调用队列组的 dispatch_group_notify 回到指定线程执行任务。或者使用 dispatch_group_wait 回到当前线程继续向下执行（会阻塞当前线程）。
5.5.1 dispatch_group_notify
监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务。
/**
* 队列组 dispatch_group_notify
*/
- (void)groupNotify {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步任务1、任务2都执行完毕后，回到主线程执行下边任务
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
NSLog(@"group---end");
});
}
输出结果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> group---begin
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 4, name = (null)}
------> 3---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> group---end
结论
- 从dispatch_group_notify相关代码运行输出结果可以看出： 当所有任务都执行完成之后，才执行dispatch_group_notify block 中的任务。
5.5.2 dispatch_group_wait
暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。
/**
* 队列组 dispatch_group_wait
*/
- (void)groupWait {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
// 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"group---end");
}
输出结果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> group---begin
------> 2---<NSThread:>{number = 4, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> group---end
结论
- 从dispatch_group_wait相关代码运行输出结果可以看出： 当所有任务执行完成之后，才执行 dispatch_group_wait 之后的操作。但是，使用dispatch_group_wait 会阻塞当前线程。
5.5.3 dispatch_group_enter、dispatch_group_leave
- dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1
- dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1。
- 当 group 中未执行完毕任务数为0的时候，才会使dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务。
/**
* 队列组 dispatch_group_enter、dispatch_group_leave
*/
- (void)groupEnterAndLeave
{
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
dispatch_group_leave(group);
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步操作都执行完毕后，回到主线程.
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
NSLog(@"group---end");
});
// // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
// dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
//
// NSLog(@"group---end");
}
输出结果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> group---begin
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> group---end
结论
- 从dispatch_group_enter、dispatch_group_leave相关代码运行结果中可以看出：当所有任务执行完成之后，才执行 dispatch_group_notify 中的任务。这里的dispatch_group_enter、dispatch_group_leave组合，其实等同于dispatch_group_async。
4.NSOperation
4.1 简介
NSOperation、NSOperationQueue 是苹果提供给我们的一套多线程解决方案。实际上 NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，完全面向对象。但是比 GCD 更简单易用、代码可读性也更高。
为什么要使用 NSOperation、NSOperationQueue？
- 可添加完成的代码块，在操作完成后执行。
- 添加操作之间的依赖关系，方便的控制执行顺序。
- 设定操作执行的优先级。
- 可以很方便的取消一个操作的执行。
- 使用 KVO 观察对操作执行状态的更改：isExecuteing、isFinished、isCancelled。
4.2 操作和队列
既然是基于 GCD 的更高一层的封装。那么，GCD 中的一些概念同样适用于 NSOperation、NSOperationQueue。在 NSOperation、NSOperationQueue 中也有类似的任务（操作） 和 队列（操作队列） 的概念。
-
操作（Operation）
- 执行操作的意思，换句话说就是你在线程中执行的那段代码。
- 在 GCD 中是放在 block 中的。在 NSOperation 中，我们使用 NSOperation 子类 NSInvocationOperation、NSBlockOperation，或者自定义子类来封装操作。
-
操作队列（Operation Queues）
- 这里的队列指操作队列，即用来存放操作的队列。不同于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。
- 操作队列通过设置 最大并发操作数（maxConcurrentOperationCount） 来控制并发、串行。
- NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。
4.3 使用步骤
NSOperation 需要配合 NSOperationQueue 来实现多线程。因为默认情况下，NSOperation 单独使用时系统同步执行操作，配合 NSOperationQueue 我们能更好的实现异步执行。
- 创建操作：先将需要执行的操作封装到一个 NSOperation 对象中。
- 创建队列：创建 NSOperationQueue 对象。
- 将操作加入到队列中：将 NSOperation 对象添加到 NSOperationQueue 对象中。
之后呢，系统就会自动将 NSOperationQueue 中的 NSOperation 取出来，在新线程中执行操作。
4.4 NSOperation 和 NSOperationQueue 基本使用
4.4.1 创建操作
NSOperation 是个抽象类，不能用来封装操作。我们只有使用它的子类来封装操作。我们有三种方式来封装操作。
1. 使用子类 NSInvocationOperation
- 在没有使用 NSOperationQueue、在主线程中单独使用使用子类 NSInvocationOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。
- 在其他线程中单独使用子类 NSInvocationOperation，操作是在当前调用的其他线程执行的，并没有开启新线程。
// 1.创建 NSInvocationOperation 对象
// 1.创建 NSInvocationOperation 对象
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];
// 2.调用 start 方法开始执行操作
[op start];
2. 使用子类 NSBlockOperation
- 一个 NSBlockOperation 对象封装了多个操作。NSBlockOperation 是否开启新线程，取决于操作的个数（NSBlockOperation 还提供了一个方法 addExecutionBlock:，通过 addExecutionBlock: 就可以为 NSBlockOperation 添加额外的操作。这些操作（包括 blockOperationWithBlock 中的操作）可以在不同的线程中同时（并发）执行。只有当所有相关的操作已经完成执行时，才视为完成）。如果添加的操作的个数多，就会自动开启新线程。当然开启的线程数是由系统来决定的。
// 1.创建 NSBlockOperation 对象
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
// do something
}];
// 2.调用 start 方法开始执行操作
[op start];
// 2.添加额外的操作
[op addExecutionBlock:^{
// do something
}];
3. 自定义继承自 NSOperation 的子类，通过实现内部相应的方法来封装操作。
- 在没有使用 NSOperationQueue、在主线程单独使用自定义继承自 NSOperation 的子类的情况下，是在主线程执行操作，并没有开启新线程
如果使用子类 NSInvocationOperation、NSBlockOperation 不能满足日常需求，我们可以使用自定义继承自 NSOperation 的子类。可以通过重写 main 或者 start 方法 来定义自己的 NSOperation 对象。重写main方法比较简单，我们不需要管理操作的状态属性 isExecuting 和 isFinished。当 main 执行完返回的时候，这个操作就结束了。
//先定义一个继承自 NSOperation 的子类，重写main方法。
// JTOperation.h 文件
#import <Foundation/Foundation.h>
@interface JTOperation : NSOperation
@end
// JTOperation.m 文件
#import "JTOperation.h"
@implementation JTOperation
- (void)main {
if (!self.isCancelled) {
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2];
NSLog(@"1---%@", [NSThread currentThread]);
}
}
}
@end
/**
* 然后使用的时候导入头文件JTOperation.h。
* 使用自定义继承自 JTOperation 的子类
*/
- (void)useCustomOperation {
// 1.创建 JTOperation 对象
JTOperation *op = [[JTOperation alloc] init];
// 2.调用 start 方法开始执行操作
[op start];
}
4.4.2 创建队列
NSOperationQueue 一共有两种队列：主队列、自定义队列。其中自定义队列同时包含了串行、并发功能。下边是主队列、自定义队列的基本创建方法和特点。
- 主队列
- 凡是添加到主队列中的操作，都会放到主线程中执行。
- 自定义队列
- 添加到这种队列中的操作，就会自动放到子线程中执行。
- 同时包含了：串行、并发功能。
// 主队列获取方法
NSOperationQueue *queue = [NSOperationQueue mainQueue];
// 自定义队列创建方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
4.4.3 将操作加入队列中
NSOperation 需要配合 NSOperationQueue 来实现多线程。那么我们需要将创建好的操作加入到队列中去。总共有两种方法：
- *- (void)addOperation:(NSOperation )op;
- 使用 NSOperation 子类创建操作，并使用 addOperation: 将操作加入到操作队列后能够开启新线程，进行并发执行。
/**
* 需要先创建操作，再将创建好的操作加入到创建好的队列中去。
*
* 使用 addOperation: 将操作加入到操作队列中
*/
- (void)addOperationToQueue {
// 1.创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.创建操作
// 使用 NSInvocationOperation 创建操作1
NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];
// 使用 NSInvocationOperation 创建操作2
NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task2) object:nil];
// 使用 NSBlockOperation 创建操作3
NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[op3 addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
}
}];
// 3.使用 addOperation: 添加所有操作到队列中
[queue addOperation:op1]; // [op1 start]
[queue addOperation:op2]; // [op2 start]
[queue addOperation:op3]; // [op3 start]
}
输出结果：
------> 4---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 4, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 4, name = (null)}
------> 4---<NSThread:>{number = 3, name = (null)}
-
- (void)addOperationWithBlock:(void (^)(void))block;
- 使用 addOperationWithBlock: 将操作加入到操作队列后能够开启新线程，进行并发执行。
/**
* 无需先创建操作，在 block 中添加操作，直接将包含操作的 block 加入到队列中。
*
* 使用 addOperation: 将操作加入到操作队列中
*/
- (void)addOperationWithBlockToQueue {
// 1.创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.使用 addOperationWithBlock: 添加操作到队列中
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
}
}];
}
输出结果：
------> 2---<NSThread:>{number = 4, name = (null)}
------> 3---<NSThread:>{number = 5, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 5, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
4.5 串行，并行控制
NSOperationQueue 创建的自定义队列同时具有串行、并发功能，上边我们演示了并发功能。它的串行功能是通过属性 最大并发操作数—maxConcurrentOperationCount 用来控制一个特定队列中可以有多少个操作同时参与并发执行。
注意：这里 maxConcurrentOperationCount 控制的不是并发线程的数量，而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行。
- 最大并发操作数：maxConcurrentOperationCount
- maxConcurrentOperationCount 默认情况下为-1，表示不进行限制，可进行并发执行。
- maxConcurrentOperationCount 为1时，队列为串行队列。只能串行执行。
- maxConcurrentOperationCount 大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整为 min{自己设定的值，系统设定的默认最大值}。
/**
* 设置 MaxConcurrentOperationCount（最大并发操作数）
*/
- (void)setMaxConcurrentOperationCount {
// 1.创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.设置最大并发操作数
queue.maxConcurrentOperationCount = 1; // 串行队列
// queue.maxConcurrentOperationCount = 2; // 并发队列
// queue.maxConcurrentOperationCount = 8; // 并发队列
// 3.添加操作
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
}
}];
}
最大并发操作数为1 输出结果：
------> 1---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 4---<NSThread:>{number = 4, name = (null)}
------> 4---<NSThread:>{number = 4, name = (null)}
最大并发操作数为2 输出结果：
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 4---<NSThread:>{number = 5, name = (null)}
------> 3---<NSThread:>{number = 6, name = (null)}
------> 4---<NSThread:>{number = 5, name = (null)}
------> 3---<NSThread:>{number = 6, name = (null)}
结论
当最大并发操作数为1时，操作是按顺序串行执行的，并且一个操作完成之后，下一个操作才开始执行。当最大操作并发数为2时，操作是并发执行的，可以同时执行两个操作。而开启线程数量是由系统决定的，不需要我们来管理。
4.6 NSOperation 操作依赖
NSOperation 提供了3个接口供我们管理和查看依赖。
- *- (void)addDependency:(NSOperation )op; 添加依赖，使当前操作依赖于操作 op 的完成。
- *- (void)removeDependency:(NSOperation )op; 移除依赖，取消当前操作对操作 op 的依赖。
- **@property (readonly, copy) NSArray<NSOperation > dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。
通过添加操作依赖，无论运行几次，其结果都是 op1 先执行，op2 后执行。
/**
* 操作依赖
* 使用方法：addDependency:
*/
- (void)addDependency {
// 1.创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.创建操作
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
}];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
// 3.添加依赖
[op2 addDependency:op1]; // 让op2 依赖于 op1，则先执行op1，在执行op2
// 4.添加操作到队列中
[queue addOperation:op1];
[queue addOperation:op2];
}
输出结果：
------> 1---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
4.7 NSOperation 优先级
NSOperation 提供了queuePriority（优先级）属性，queuePriority属性适用于同一操作队列中的操作，不适用于不同操作队列中的操作。默认情况下，所有新创建的操作对象优先级都是NSOperationQueuePriorityNormal。但是我们可以通过setQueuePriority:方法来改变当前操作在同一队列中的执行优先级。
// 优先级的取值
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
NSOperationQueuePriorityVeryLow = -8L,
NSOperationQueuePriorityLow = -4L,
NSOperationQueuePriorityNormal = 0,
NSOperationQueuePriorityHigh = 4,
NSOperationQueuePriorityVeryHigh = 8
};
对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。
理解了进入就绪状态的操作，那么我们就理解了queuePriority 属性的作用对象。
- queuePriority 属性决定了进入准备就绪状态下的操作之间的开始执行顺序。并且，优先级不能取代依赖关系。
- 如果一个队列中既包含高优先级操作，又包含低优先级操作，并且两个操作都已经准备就绪，那么队列先执行高优先级操作。
- 如果，一个队列中既包含了准备就绪状态的操作，又包含了未准备就绪的操作，未准备就绪的操作优先级比准备就绪的操作优先级高。那么，虽然准备就绪的操作优先级低，也会优先执行。优先级不能取代依赖关系。如果要控制操作间的启动顺序，则必须使用依赖关系。
4.8 NSOperation 线程间通信
/**
* 线程间通信
*/
- (void)communication {
// 1.创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc]init];
// 2.添加操作
[queue addOperationWithBlock:^{
// 异步进行耗时操作
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
}
// 回到主线程
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
// 进行一些 UI 刷新等操作
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
}
}];
}];
}
输出结果：
------> 1---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
4.9 NSOperation、NSOperationQueue 常用属性和方法归纳
-
NSOperation 常用属性和方法
- 取消操作的方法
- - (void)cancel; 可取消操作，实质是标记 isCancelled 状态。
- 判断操作状态的方法
- - (BOOL)isFinished; 判断操作是否已经结束。
- - (BOOL)isCancelled; 判断操作是否已经标记为取消。
- - (BOOL)isExecuting; 判断操作是否正在在运行。
- - (BOOL)isReady; 判断操作是否处于准备就绪状态，这个值和操作的依赖关系相关。
- 操作同步
- - (void)waitUntilFinished; 阻塞当前线程，直到该操作结束。可用于线程执行顺序的同步。
- - (void)setCompletionBlock:(void (^)(void))block; completionBlock 会在当前操作执行完毕时执行 completionBlock。
- *- (void)addDependency:(NSOperation )op; 添加依赖，使当前操作依赖于操作 op 的完成。
- *- (void)removeDependency:(NSOperation )op; 移除依赖，取消当前操作对操作 op 的依赖。
- **@property (readonly, copy) NSArray<NSOperation > dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组
- 取消操作的方法
-
NSOperationQueue 常用属性和方法
- 取消/暂停/恢复操作
- - (void)cancelAllOperations; 可以取消队列的所有操作。
- - (BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。
- - (void)setSuspended:(BOOL)b; 可设置操作的暂停和恢复，YES 代表暂停队列，NO 代表恢复队列。
- 操作同步
- - (void)waitUntilAllOperationsAreFinished; 阻塞当前线程，直到队列中的操作全部执行完毕。
- 添加/获取操作
- - (void)addOperationWithBlock:(void (^)(void))block; 向队列中添加一个 NSBlockOperation 类型操作对象
- *- (void)addOperations:(NSArray )ops waitUntilFinished:(BOOL)wait; 向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束
- *- (NSArray )operations; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）。
- - (NSUInteger)operationCount; 当前队列中的操作数。
- 获取队列
- + (id)currentQueue; 获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。
- + (id)mainQueue; 获取主队列。
- 取消/暂停/恢复操作
注意:
- 这里的暂停和取消（包括操作的取消和队列的取消）并不代表可以将当前的操作立即取消，而是当当前的操作执行完毕之后不再执行新的操作。
- 暂停和取消的区别就在于：暂停操作之后还可以恢复操作，继续向下执行；而取消操作之后，所有的操作就清空了，无法再接着执行剩下的操作。
