多执行绪是一种相当轻量的手段,让同一个应用内部可以拥有多条并行的代码执行路径。在系统层面,多个程序看起来是同时运行的,但每个程序实际分到的执行时间,取决于它自身的需求以及其他程序的负载情况;而在单个程序内部,则存在一个或多个执行绪,以「同时」或「几乎同时」的方式完成不同任务。
先说一个容易被忽略的前提:iPhone 上的执行绪并非无限量供应。官方资料显示,iOS 主执行绪的堆栈大小约为 1MB,从第二个执行绪开始就降为 512KB,而且这个值无法通过编译器开关或执行绪 API 调整。另外,只有主执行绪拥有直接操作 UI 的能力——这一点是后面所有讨论的基础。
有些程序像一条直线,从起点跑到终点就结束,例如最简单的 Hello World,打印完生命周期便告终。有些程序则像一个圆,不断循环直到被外力切断,例如操作系统,一直运行到你关机为止。
一个正在运行的程序称为「进程」(process)或任务,而一个进程至少包含一个执行绪——执行绪就是程序的执行流。在 Mac 与 iOS 上,程序启动、进程创建的同时就会有一个执行绪开始运作,这就是主执行绪(main thread)。主执行绪在进程中的地位特殊:它是其他执行绪最终的父执行绪,并且所有界面显示相关的操作(AppKit 或 UIKit)都必须在主执行绪中进行。
系统中每个进程都拥有独立的虚拟内存空间,而同一进程内的多个执行绪共用进程的内存空间。每建立一个新执行绪,都需要额外的内存(例如各自的 stack 空间)并消耗一定的 CPU 时间。也正因为共用内存,当多个执行绪争抢同一份资源时,就必须认真处理执行绪安全问题。
建立执行绪本质上是给进程增加一条执行流,因此必须提供一个函数或方法作为执行绪的入口。iOS 上常见的做法有以下几种。
NSThread 是最直接的路径,除了建立执行绪,还提供了判断当前是否为主执行绪的方法。两种常见写法:
start:可以用「目标对象 + 方法」初始化,也可以继承 NSThread 并覆写 main 方法。detachNewThreadSelector:toTarget:withObject:,直接把目标对象的方法当作执行绪入口,写法最为简洁。NSObject 本身就内建了对多执行绪的支持,允许把某个方法丢到背景执行:
[myObj performSelectorInBackground:@selector(doSomething) withObject:nil];
由于 Mac 与 iOS 都基于 Darwin,而 Darwin 的 Mach/BSD 内核继承了 BSD 的 POSIX 接口,所以可以直接使用 POSIX 执行绪 API。建立执行绪的接口是 pthread_create,在建立之前还可以先设定好执行绪属性。
实战中我们往往需要控制同时运行的并发数。执行绪本身要消耗系统资源,程序中同时跑的执行绪一多,系统整体必然变慢。NSOperation 把「操作」封装成对象,放进 NSOperationQueue 之后,队列会自行启动执行绪来消化这些操作,而并发数可以通过下面的方法设定:
- (void)setMaxConcurrentOperationCount:(NSInteger)count
至于 GCD(Grand Central Dispatch),它是一组 BSD 层面的接口,从 Mac 10.6 与 iOS 4.0 起引入,如今 NSOperation 与 NSOperationQueue 的多执行绪实作正是建立在 GCD 之上。这个特性后来也被移植到 FreeBSD,可以从 libdispatch 这个开源项目查看。除了处理多执行绪,GCD 建立在强大的 kqueue 之上,效率也相当有保障:
dispatch_queue_t imageDownloadQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
为什么一定要用多执行绪?为了界面流畅度与使用体验,耗时操作必须丢到别的执行绪,绝对不要阻塞主执行绪。iOS 上常见的三种做法:
NSThread 是最轻量、最直观的多执行绪方案,但因为需要自己管理执行绪生命周期与同步,通常只适合用来调试,实际项目中并不推荐。
// 取得当前执行绪 NSThread *current = [NSThread currentThread]; // 取得主执行绪 NSThread *main = [NSThread mainThread]; NSLog(@"当前执行绪 --- %@", current); NSLog(@"主执行绪 --- %@", main);
控制台输出:
2015-11-22 22:30:29.572 多执行绪demo[1289:2925847] 当前执行绪 --- <NSThread: 0x7fc0e1401dc0>{number = 1, name = main}
2015-11-22 22:30:29.572 多执行绪demo[1289:2925847] 主执行绪 --- <NSThread: 0x7fc0e1401dc0>{number = 1, name = main}
可以看出当前执行绪就是主执行绪;number 相当于执行绪的 id,name 是名称,而主执行绪的 number 固定为 1。
阻塞执行绪的写法:
// 阻塞 3 秒 [NSThread sleepForTimeInterval:3]; [NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:3]];
GCD 是一套基于 C 语言底层 API 的多执行绪并发机制,非常灵活方便,在实际开发中使用极广。简单来说,GCD 就是把「操作」放进「队列」中执行:你只需要定义好操作与队列,不必直接管理执行绪的创建与销毁,执行绪的生命周期由队列全权负责。
队列负责操作的调度与执行,具有先进先出(FIFO)的特性——先加入的先执行,后加入的后执行。队列分两种:
串行队列:队列中的操作只会按顺序执行,可以想成单窗口排队。

并行队列:队列中的操作可能并发执行(实际取决于操作类型),可以想成多窗口排队。

// 建立串行队列
dispatch_queue_t q = dispatch_queue_create("my_serial_queue", DISPATCH_QUEUE_SERIAL);
// 建立并行队列
dispatch_queue_t q = dispatch_queue_create("my_concurrent_queue", DISPATCH_QUEUE_CONCURRENT);
其中 my_serial_queue 与 my_concurrent_queue 是队列的标签名称,为了和其他队列区分,在同一个项目内必须唯一;DISPATCH_QUEUE_SERIAL 表示串行队列,DISPATCH_QUEUE_CONCURRENT 表示并行队列。
操作同样分两种类型:
用 block 定义要执行的代码,q 是已经定义好的目标队列:
// 同步操作
dispatch_sync(q, ^{ /* 要执行的代码 */ });
// 异步操作
dispatch_async(q, ^{ /* 要执行的代码 */ });
组合一:同步操作 + 串行/并行队列——不管加入哪种队列,都只在主执行绪按顺序执行。
dispatch_queue_t q_serial = dispatch_queue_create("my_serial_queue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t q_concurrent = dispatch_queue_create("my_concurrent_queue", DISPATCH_QUEUE_CONCURRENT);
for (int i = 0; i < 5; ++i) {
dispatch_sync(q_serial, ^{
NSLog(@"串行队列里的同步任务 %@ %d", [NSThread currentThread], i);
});
}
for (int i = 0; i < 5; ++i) {
dispatch_sync(q_concurrent, ^{
NSLog(@"并行队列里的同步任务 %@ %d", [NSThread currentThread], i);
});
}
输出结果(注意 number 都是 1,即主执行绪):
2015-11-23 00:40:36.862 串行队列里的同步任务 <NSThread: 0x7ff833505450>{number = 1, name = main} 0
2015-11-23 00:40:36.863 串行队列里的同步任务 <NSThread: 0x7ff833505450>{number = 1, name = main} 1
2015-11-23 00:40:36.863 串行队列里的同步任务 <NSThread: 0x7ff833505450>{number = 1, name = main} 2
2015-11-23 00:40:36.863 串行队列里的同步任务 <NSThread: 0x7ff833505450>{number = 1, name = main} 3
2015-11-23 00:40:36.863 串行队列里的同步任务 <NSThread: 0x7ff833505450>{number = 1, name = main} 4
2015-11-23 00:40:36.863 并行队列里的同步任务 <NSThread: 0x7ff833505450>{number = 1, name = main} 0
2015-11-23 00:40:36.863 并行队列里的同步任务 <NSThread: 0x7ff833505450>{number = 1, name = main} 1
2015-11-23 00:40:36.863 并行队列里的同步任务 <NSThread: 0x7ff833505450>{number = 1, name = main} 2
2015-11-23 00:40:36.864 并行队列里的同步任务 <NSThread: 0x7ff833505450>{number = 1, name = main} 3
2015-11-23 00:40:36.864 并行队列里的同步任务 <NSThread: 0x7ff833505450>{number = 1, name = main} 4
组合二:异步操作 + 串行队列——只在非主执行绪运行,并且会在新建的执行绪中按顺序执行。
dispatch_queue_t q_serial = dispatch_queue_create("my_serial_queue", DISPATCH_QUEUE_SERIAL);
for (int i = 0; i < 5; ++i) {
dispatch_async(q_serial, ^{
NSLog(@"串行队列 -- 异步任务 %@ %d", [NSThread currentThread], i);
});
}
因为是异步操作,所以会新建一个执行绪(number = 2);又因为加入了串行队列,所有操作只会按顺序执行。
2015-11-23 01:03:22.372 串行队列 -- 异步任务 <NSThread: 0x7fb593d42f50>{number = 2, name = (null)} 0
2015-11-23 01:03:23.373 串行队列 -- 异步任务 <NSThread: 0x7fb593d42f50>{number = 2, name = (null)} 1
2015-11-23 01:03:24.374 串行队列 -- 异步任务 <NSThread: 0x7fb593d42f50>{number = 2, name = (null)} 2
2015-11-23 01:03:25.375 串行队列 -- 异步任务 <NSThread: 0x7fb593d42f50>{number = 2, name = (null)} 3
2015-11-23 01:03:26.376 串行队列 -- 异步任务 <NSThread: 0x7fb593d42f50>{number = 2, name = (null)} 4
组合三:异步操作 + 并行队列——理论上会为每个异步操作新建执行绪并让它们并发执行。
dispatch_queue_t q_concurrent = dispatch_queue_create("my_concurrent_queue", DISPATCH_QUEUE_CONCURRENT);
for (int i = 0; i < 5; ++i) {
dispatch_async(q_concurrent, ^{
NSLog(@"并行队列 -- 异步任务 %@ %d", [NSThread currentThread], i);
});
}
但系统能创建的执行绪数量是有限的。当达到最大执行绪数后,后面的异步操作就必须等待前面的操作执行完毕;哪个执行绪先空出来,就把等待中的任务派给它,直到全部完成。把循环次数改成 5000 就能清楚观察到这个现象。
2015-11-23 01:14:15.282 并行队列 -- 异步任务 <NSThread: 0x7fb3b841b0a0>{number = 4, name = (null)} 3
2015-11-23 01:14:15.282 并行队列 -- 异步任务 <NSThread: 0x7fb3b8514da0>{number = 3, name = (null)} 0
2015-11-23 01:14:15.282 并行队列 -- 异步任务 <NSThread: 0x7fb3b8604db0>{number = 5, name = (null)} 2
2015-11-23 01:14:15.282 并行队列 -- 异步任务 <NSThread: 0x7fb3b86119d0>{number = 2, name = (null)} 1
2015-11-23 01:14:15.285 并行队列 -- 异步任务 <NSThread: 0x7fb3b87011f0>{number = 6, name = (null)} 4
GCD 功能虽强,但 API 终究是 C 语言的。在某些时候,于面向对象的 Objective-C 代码中使用起来既不方便也不安全,因此苹果把 GCD 中的「操作」抽象成 NSOperation 对象,把「队列」抽象成 NSOperationQueue 对象。

抽象之后带来的好处:
NSOperation 分为 NSInvocationOperation 与 NSBlockOperation 两种。
NSInvocationOperation 的使用
// 先建立 NSOperationQueue
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self
selector:@selector(operationAction:)
object:@"这里可以传参数"];
[queue addOperation:op]; // 加入队列即开始执行
- (void)operationAction:(id)obj {
NSLog(@"%@ - obj : %@", [NSThread currentThread], obj);
}
输出:
2015-11-23 02:55:19.067 多执行绪demo[2604:3686934] <NSThread: 0x7f9dfa443510>{number = 2, name = (null)} - obj : 这里可以传参数
NSBlockOperation 的使用
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
[self operationAction:@"这是 NSBlockOperation"];
}];
[queue addOperation:op];
输出:
2015-11-23 02:56:11.812 多执行绪demo[2617:3687872] <NSThread: 0x7fa983f10a50>{number = 2, name = (null)} - obj : 这是 NSBlockOperation
设置依赖关系(决定执行顺序)
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self
selector:@selector(operationAction:)
object:@"op1"];
NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self
selector:@selector(operationAction:)
object:@"op2"];
// 让 op2 在 op1 之后执行
[op2 addDependency:op1]; // 注意:必须在 addOperation 之前设置依赖
[queue addOperation:op1];
[queue addOperation:op2];
输出(注意两次落在同一个执行绪上):
2015-11-23 02:57:40.283 多执行绪demo[2661:3689737] <NSThread: 0x7fb663e132d0>{number = 2, name = (null)} - obj : op1
2015-11-23 02:57:40.284 多执行绪demo[2661:3689737] <NSThread: 0x7fb663e132d0>{number = 2, name = (null)} - obj : op2
没有设置依赖时的输出(顺序错乱,且落在不同执行绪):
2015-11-23 03:00:45.939 多执行绪demo[2709:3692307] <NSThread: 0x7fe951d0d8a0>{number = 2, name = (null)} - obj : op2
2015-11-23 03:00:45.939 多执行绪demo[2709:3692308] <NSThread: 0x7fe951c24720>{number = 3, name = (null)} - obj : op1
调试与学习阶段用 NSThread 最直观;追求轻量与性能、且不需要复杂依赖管理时,GCD 是最主流的选择;一旦需要设置操作之间的依赖、取消任务或控制最大并发数,就应该改用 NSOperation 与 NSOperationQueue——你不再需要像 GCD 那样分别定义「操作类型」和「队列类型」,只要直接描述操作之间的先后顺序即可。