您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發綜合

iOS 三种多线程编程实作详解:NSThread、GCD 与 NSOperation

編輯:iOS 開發綜合

为了让界面保持流畅、用户体验不被拖累,耗时的工作必须搬到其他线程去执行,千万不要阻塞主线程。这是所有多线程讨论的出发点。iOS 平台上常见的多线程方案有三种:NSThread、Grand Central Dispatch(GCD),以及 NSOperation 与 NSOperationQueue。下面逐一拆解。

一、NSThread:最轻量也最原始

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:把操作丢进队列执行

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);
    });
}

控制台输出:

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

三、NSOperation 与 NSOperationQueue

GCD 的功能已经很强大,但它的 API 依旧是 C 语言的。在某些场景下,于面向对象的 Objective-C 中使用起来非常不方便,也不够安全。于是苹果把 GCD 中的操作抽象成 NSOperation 对象,把队列抽象成 NSOperationQueue 对象。

抽象成 NSOperation 与 NSOperationQueue 之后的好处:

  • 代码风格统一了,不必在面向对象的 Objective-C 中写面向过程的 C 代码。
  • GCD 中操作的执行代码都写在匿名 block 里,很难为操作设置依赖关系或取消操作;这些能力都已封装进 NSOperation 对象。
  • NSOperationQueue 比 GCD 的队列更强大灵活,例如可以设置并发操作数量、取消队列中的所有操作。

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

小结

到这里你应该发现了:在 NSOperation 与 NSOperationQueue 中,我们不需要再像 GCD 那样分别定义操作类型、队列类型并间接控制执行顺序,只要直接描述操作之间的先后顺序就好。三种方案的定位可以这样记:NSThread 适合学习与调试,GCD 适合大多数轻量并发场景,NSOperation 系列适合需要依赖管理、任务取消与并发数控制的复杂流程。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved