iOS开发——多线程OC篇&多线程详解

浏览数：57 / 时间：2015年06月11日

多线程详解

前面介绍了多线程的各种方式及其使用，这里补一点关于多线程的概念及相关技巧与使用，相信前面不懂的地方看了这里之后你就对多线程基本上没有什么问题了！

1——首先ios开发多线程中必须了解的概念：

进程

正在进行中的程序被称为进程，负责程序运行的内存分配
每一个进程都有自己独立的虚拟内存空间

线程

线程是进程中一个独立的执行路径(控制单元)
一个进程中至少包含一条线程，即主线程
可以将耗时的执行路径(如：网络请求)放在其他线程中执行
创建线程的目的就是为了开启一条新的执行路径，运行指定的代码，与主线程中的代码实现同时运行

2——多线程的三种方式：

NSThread

使用NSThread对象建立一个线程非常方便
但是！要使用NSThread管理多个线程非常困难，不推荐使用
技巧！使用[NSThread currentThread]跟踪任务所在线程，适用于这三种技术

NSOperation/NSOperationQueue

是使用GCD实现的一套Objective-C的API
是面向对象的线程技术
提供了一些在GCD中不容易实现的特性，如：限制最大并发数量、操作之间的依赖关系

GCD —— Grand Central Dispatch

是基于C语言的底层API
用Block定义任务，使用起来非常灵活便捷
提供了更多的控制能力以及操作队列中所不能使用的底层函数

3——开发中最常用到的GCD：

GCD的基本思想是就将操作s放在队列s中去执行

操作使用Blocks定义
队列负责调度任务执行所在的线程以及具体的执行时间
队列的特点是先进先出(FIFO)的，新添加至对列的操作都会排在队尾

提示
GCD的函数都是以dispatch(分派、调度)开头的
队列
dispatch_queue_t

串行队列，队列中的任务只会顺序执行
并行队列，队列中的任务通常会并发执行

操作

dispatch_async 异步操作，会并发执行，无法确定任务的执行顺序
dispatch_sync 同步操作，会依次顺序执行，能够决定任务的执行顺序

4——串行队列：

dispatch_queue_t q = dispatch_queue_create("cn.itcast.demoqueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(q, ^{
NSLog(@"串行同步 %@", [NSThread currentThread]);
});
dispatch_async(q, ^{
NSLog(@"串行异步 %@", [NSThread currentThread]);
});

5——并行队列：

dispatch_queue_t q = dispatch_queue_create("cn.itcast.demoqueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(q, ^{
NSLog(@"并行同步 %@", [NSThread currentThread]);
});
dispatch_async(q, ^{
NSLog(@"并行异步 %@", [NSThread currentThread]);
});

6——：全局队列：

dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(q, ^{
NSLog(@"全局异步 %@ %d", [NSThread currentThread], i);
});
dispatch_sync(q, ^{
NSLog(@"全局同步 %@ %d", [NSThread currentThread], i);
});

7——主队列：

dispatch_queue_t q = dispatch_get_main_queue();

dispatch_async(q, ^{
NSLog(@"主队列异步 %@", [NSThread currentThread]);
});
dispatch_sync(q, ^{
NSLog(@"主队列同步 %@", [NSThread currentThread]);
});

8——不同队列中嵌套dispatch_sync的结果：

// 全局队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 并行队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_queue_create("cn.itcast.gcddemo", DISPATCH_QUEUE_CONCURRENT);
// 串行队列，会死锁，但是会执行嵌套同步操作之前的代码
dispatch_queue_t q = dispatch_queue_create("cn.itcast.gcddemo", DISPATCH_QUEUE_SERIAL);
// 直接死锁
dispatch_queue_t q = dispatch_get_main_queue();
dispatch_sync(q, ^{
NSLog(@"同步任务 %@", [NSThread currentThread]);
dispatch_sync(q, ^{
NSLog(@"同步任务 %@", [NSThread currentThread]);
});
});

9——：dispatch_sync的应用场景

阻塞并行队列的执行，要求某一操作执行后再进行后续操作，如用户登录
确保块代码之外的局部变量确实被修改

dispatch_queue_t q = dispatch_queue_create("cn.itcast.gcddemo", DISPATCH_QUEUE_CONCURRENT);
__block BOOL logon = NO;
dispatch_sync(q, ^{
NSLog(@"模拟耗时操作 %@", [NSThread currentThread]);
[NSThread sleepForTimeInterval:2.0f];
NSLog(@"模拟耗时完成 %@", [NSThread currentThread]);
logon = YES;
});
dispatch_async(q, ^{
NSLog(@"登录完成的处理 %@", [NSThread currentThread]);
});

注：

串行队列，同步任务，不需要新建线程
串行队列，异步任务，需要一个子线程，线程的创建和回收不需要程序员参与！
“是最安全的一个选择”串行队列只能创建！
并行队列，同步任务，不需要创建线程
并行队列，异步任务，有多少个任务，就开N个线程执行，

无论什么队列和什么任务，线程的创建和回收不需要程序员参与。
线程的创建回收工作是由队列负责的

“并发”编程，为了让程序员从负责的线程控制中解脱出来！只需要面对队列和任务！

10——GCD小结：

GCD

通过GCD，开发者不用再直接跟线程打交道，只需要向队列中添加代码块即可
GCD在后端管理着一个线程池，GCD不仅决定着代码块将在哪个线程被执行，它还根据可用的系统资源对这些线程进行管理。从而让开发者从线程管理的工作中解放出来，通过集中的管理线程，缓解大量线程被创建的问题
使用GCD，开发者可以将工作考虑为一个队列，而不是一堆线程，这种并行的抽象模型更容易掌握和使用

GCD的队列

GCD公开有5个不同的队列：运行在主线程中的主队列，3 个不同优先级的后台队列，以及一个优先级更低的后台队列（用于 I/O）
自定义队列：串行和并行队列。自定义队列非常强大，建议在开发中使用。在自定义队列中被调度的所有Block最终都将被放入到系统的全局队列中和线程池中
提示：不建议使用不同优先级的队列，因为如果设计不当，可能会出现优先级反转，即低优先级的操作阻塞高优先级的操作

11——NSOperationQueue：

简介
NSOperationQueue(操作队列)是由GCD提供的队列模型的Cocoa抽象，是一套Objective-C的API
GCD提供了更加底层的控制，而操作队列则在GCD之上实现了一些方便的功能，这些功能对于开发者而言通常是最好最安全的选择
队列及操作
NSOperationQueue有两种不同类型的队列：主队列和自定义队列
主队列运行在主线程上
自定义队列在后台执行
队列处理的任务是NSOperation的子类
NSInvocationOperation
NSBlockOperation

基本步骤：

基本使用步骤
定义操作队列
定义操作
将操作添加到队列

提示：一旦将操作添加到队列，操作就会立即被调度执行

12——NSInvocationOperation(调度操作)：

定义队列
self.myQueue = [[NSOperationQueue alloc] init];
操作调用的方法

- (void)operationAction:(id)obj
{
NSLog(@"%@ - obj : %@", [NSThread currentThread], obj);
}

定义操作并添加到队列

NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationAction:) object:@(i)];
[self.myQueue addOperation:op];

小结：需要准备一个被调度的方法，并且能够接收一个参数

13——NSBlockOperation(块操作)：

定义操作并添加到队列

NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
[self operationAction:@"Block Operation"];
}];

将操作添加到队列
[self.myQueue addOperation:op];

小结：NSBlockOperation比NSInvocationOperation更加灵活

14——设置操作的依赖关系：

NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"%@ - 下载图片", [NSThread currentThread]);
}];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"%@ - 添加图片滤镜", [NSThread currentThread]);
}];
NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"%@ - 更新UI", [NSThread currentThread]);
}];
[op2 addDependency:op1];
[op3 addDependency:op2];
[self.myQueue addOperation:op1];
[self.myQueue addOperation:op2];
[[NSOperationQueue mainQueue] addOperation:op3];

提示：利用addDependency可以指定操作之间的彼此依赖关系(执行先后顺序)
注意：不要出现循环依赖！

15——设置同步并发线程数：

[self.myQueue setMaxConcurrentOperationCount:2];
for (int i = 0; i < 10; ++i) {
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
[self operationAction:@(i)];
}];
[self.myQueue addOperation:op];
}

问题
块代码中的self为什么不会造成循环引用？

16——NSOperation小结：

从本质上来看，操作队列的性能会比GCD略低，不过，大多数情况下这点负面影响可以忽略不计，操作队列是并发编程的首选工具

AFN，底层用GCD开发，开发的接口是NSOperation的

17——Run Loop：

Run Loop提供了一种异步执行代码的机制，不能并行执行任务
在主队列中，Main Run Loop直接配合任务的执行，负责处理UI事件、计时器，以及其它内核相关事件
Run Loop的主要目的是保证程序执行的线程不会被系统终止

Run Loop的工作特点

当有事件发生时，Run Loop会根据具体的事件类型通知应用程序做出响应
当没有事件发生时，Run Loop会进入休眠状态，从而达到省电的目的
当事件再次发生时，Run Loop会被重新唤醒，处理事件
主线程和其他线程中的Run Loop
iOS程序的主线程默认已经配置好了Run Loop
其他线程默认情况下没有设置Run Loop

一般在开发中很少会主动创建RunLoop，而通常会把事件添加到RunLoop中

18——多线程中循环引用：

如果self对象持有操作对象的引用，同时操作对象当中又直接访问了self时，才会造成循环引用

单纯在操作对象中使用self不会造成循环引用

注意：此时不能使用(weakSelf)

19——多线程中资源共享：

并发编程中许多问题的根源就是在多线程中访问共享资源。资源可以是一个属性、一个对象、网络设备或者一个文件等
在多线程中任何一个共享的资源都可能是一个潜在的冲突点，必须精心设计以防止这种冲突的发生

20——更新UI：

#pragma mark 设置提示信息文本
- (void)setInfoText:(NSString *)infoText
{
if (infoText.length == 0) {
self.infoTextView.text = @"";
return;
}
// 1. 取出当前textView中的内容
NSMutableString *strM = [self.infoTextView.text mutableCopy];
// 2. 追加文本
[strM appendFormat:@"%@\n", infoText];
// 3. 设置textView中的内容
self.infoTextView.text = [strM copy];
// 4. 滚动到文本框的末尾
NSRange r = NSMakeRange(strM.length - 1, 1);
[self.infoTextView scrollRangeToVisible:r];
}

21——贡献资源小结：

为了保证性能，atomic仅针对属性的setter方法做了保护
而争抢共享资源时，如果涉及到属性的getter方法，可以使用互斥锁@synchronized可以保证属性在多个线程之间的读写都是安全的
无论是atomic还是@synchronized，使用的代价都是高昂的

建议：多线程是并发执行多个任务提高效率的，如果可能，应该在线程中避免争抢共享资源

正是出于性能的考虑，UIKit中的绝大多数的类都不是线程安全的，因此，苹果公司要求：更新UI相关的操作，应该在主线程中执行

取舍！

22——单例：

单例模式是一种常用的软件设计模式
通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源
如果希望系统中某个类的对象只能存在一个，单例模式是最好的解决方案

iOS中最常见的单例就是UIApplication

应用场景：

音频播放，背景音乐！
硬件资源：加速器、[UIScreen mainScreen]
sharedXX, mainXXX

实现步骤

重写allocWithZone方法
allocWithZone方法是对象分配内存空间时，最终会调用的方法，重写该方法，保证只会分配一个内存空间
建立sharedXXX类方法，便于其他类访问

+ (id)allocWithZone:(struct _NSZone *)zone
{
static Ticket *instance;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
instance = [super allocWithZone:zone];
});
return instance;
}

小结：

优点
可以阻止其他对象实例化单例对象的副本，从而确保所有对象都访问唯一实例

缺点
单例对象一旦建立，对象指针是保存在静态区的，单例对象在堆中分配的内存空间，会在应用程序终止后才会被释放

提示
只有确实需要唯一使用的对象才需要考虑单例模式，不要滥用单例

23——NSObject多线程：

开启后台执行任务的方法
- (void)performSelectorInBackground:(SEL)aSelector withObject:(id)arg
在后台线程中通知主线程执行任务的方法
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait
获取线程信息
[NSThread currentThread]
线程休眠
[NSThread sleepForTimeInterval:2.0f];

特点