iOS之多线程
首先来了解什么是多线程,进程和线程的区别.
进程:
正在进行中的程序被称为进程,负责程序运行的内存分配;
每一个进程都有自己独立的虚拟内存空间.
线程:(主线程最大占1M的栈区空间,每条子线程最大占512K的栈区空间)
线程是进程中一个独立的执行路径(控制单元);
一个进程中至少包含一条线程,即主线程;
可以将耗时的执行路径(如网络请求)放在其他线程中执行;
线程不能被杀掉,但是可以暂停/休眠一条线程.
创建线程的目的:
开启一条新的执行路径,运行指定的代码,与主线程中的代码实现同时运行.
多任务调度系统:
每个应用程序由操作系统分配的短暂的时间片(Timeslice)轮流使用CPU,由于CPU对每个时间片的处理速度非常快,因此,用户看来这些任务好像是同时执行的.
并发:
指两个或多个任务在同一时间间隔内发生,但是,在任意一个时间点上,CPU只会处理一个任务.
多线程的优势:
1> 充分发挥多核处理器优势,将不同线程任务分配给不同的处理器,真正进入"并行运算"状态;
2> 将耗时的任务分配到其他线程执行,由主线程负责统一更新界面会使应用程序更加流畅,用户体验更好;
3> 当硬件处理器的数量增加,程序会运行更快,而程序无需做任何调整.
弊端:
新建线程会消耗内存空间和CPU时间,线程太多会降低系统的运行性能.
iOS的三种多线程技术特点:
1.NSThread:
1> 使用NSThread对象建立一个线程非常方便;
2> 但是!要使用NSThread管理多个线程非常困难,不推荐使用;
3> 技巧!使用[NSThread currentThread]跟踪任务所在线程,适用于这三种技术.
2.NSOperation/NSOperationQueue:
1> 是使用GCD实现的一套Objective-C的API;
2> 是面向对象的多线程技术;
3> 提供了一些在GCD中不容易实现的特性,如:限制最大并发数量,操作之间的依赖关系.
3.GCD---Grand Central Dispatch:
1> 是基于C语言的底层API;
2> 用Block定义任务,使用起来非常灵活便捷;
3> 提供了更多的控制能力以及操作队列中所不能使用的底层函数.
iOS的开发者需要了解三种多线程技术的基本使用,因为在实际开发中会根据实际情况选择不同的多线程技术.
一、NSThread线程管理
NSTread是iOS中进行多线程开发的一个类，其结构逻辑清晰，使用十分方便，但其封装度和性能不高，线程周期，加锁等需要手动处理。
1、NSThread类方法总结
获取当前线程
+ (NSThread *)currentThread;
开启一个新的线程执行选择器方法（新启的线程和主线程是异步的）
+ (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(id)argument;
程序是否是多线程执行
+ (BOOL)isMultiThreaded;
线程字典，我们可以为特殊的线程设置键值对
@property (readonly, retain) NSMutableDictionary *threadDictionary;
线程在某个时间执行
+ (void)sleepUntilDate:(NSDate *)date;
线程在等待一个时间间隔后执行
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;
结束线程
+ (void)exit;
设置线程的优先级，取值的范围为0-1
+ (double)threadPriority;
+ (BOOL)setThreadPriority:(double)p;
这个属性是iOS8之后的新特性，将优先级更人性化的封装了起来
@property NSQualityOfService qualityOfService;
NSQualityOfService的枚举如下：
typedef NS_ENUM(NSInteger, NSQualityOfService) {
//刷新UI级别的线程
NSQualityOfServiceUserInteractive = 0x21,
//用户请求的无需精确的任务的线程，例如点击加载邮件
NSQualityOfServiceUserInitiated = 0x19,
//周期性的任务线程，例如定时刷新
NSQualityOfServiceUtility = 0x11,
//后台任务的线程
NSQualityOfServiceBackground = 0x09,
//优先级未知的线程，优先级介于UserInteractive和Utility之间
NSQualityOfServiceDefault = -1
}；
判断是否是主线程
+ (BOOL)isMainThread
获取主线程
+ (NSThread *)mainThread
2、属性与成员方法总结
初始化方法，选择器可以带一个参数
- (instancetype)initWithTarget:(id)target selector:(SEL)selector object:(id)argument;
线程是否正在执行
@property (readonly, getter=isExecuting) BOOL executing;
线程是否已经执行结束
@property (readonly, getter=isFinished) BOOL finished;
线程是否已经取消执行
@property (readonly, getter=isCancelled) BOOL cancelled;
3、隐式的通过NSThread进行多线程编程
@interface NSObject (NSThreadPerformAdditions)
在主线程执行一个选择器，arg是参数，wait是是否立即执行，如果YES，则会阻塞当前主线程的任务，NO则会等待当前任务结束后执行。
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
这个函数指定在某个线程执行选择器
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait;
指定在后台线程中执行选择器
- (void)performSelectorInBackground:(SEL)aSelector withObject:(id)arg;
二、NSOperation&NSOperationQueue
简介:
1> NSOperationQueue(操作队列)是由GCD提供的队列模型的Cocoa抽象,是一套Objective-C的API;
2> GCD提供了更加底层的控制,而NSOperationQueue(操作队列)则在GCD之上实现了一些方便的功能,这些功能对开发者而言通常是最好最安全的选择.
队列及操作:
NSOperationQueue有两种不同类型的队列:主队列和自定义队列.
主队列运行在主线程上,自定义队列在子线程执行.
队列处理的任务是NSOperation的子类:NSInvocationOperation 和 NSBlockOperation.
1、NSOperation解析
@interface NSOperation : NSObject
NSOperation的基本使用步骤:
定义操作队列 --> 定义操作 -->将操作添加到队列.
提示:
一旦将操作添加到队列,操作就会立即被调度执行.
1、NSOperation抽象类中提供的逻辑方法
操作开始执行(如果不放在队列中，则需执行此方法才能开始执行)
- (void)start;
在子类中可以重写这个方法，实现执行的方法
- (void)main;
取消执行
- (void)cancel;
获取当操作状态的几个属性
@property (readonly, getter=isCancelled) BOOL cancelled;//当前操作是否取消执行
@property (readonly, getter=isExecuting) BOOL executing;//当前操作是否正在执行
@property (readonly, getter=isFinished) BOOL finished;//当前操作是否执行结束
@property (readonly, getter=isAsynchronous) BOOL asynchronous;//当前操作是否在异步线程中
@property (readonly, getter=isReady) BOOL ready;//当前操作是否已经准备好
阻塞当前线程直到操作完成
- (void)waitUntilFinished;
设置在操作队列中的优先级
@property NSOperationQueuePriority queuePriority;
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
NSOperationQueuePriorityVeryLow = -8L,//优先级很低
NSOperationQueuePriorityLow = -4L,//优先级低
NSOperationQueuePriorityNormal = 0,//优先级普通
NSOperationQueuePriorityHigh = 4,//优先级高
NSOperationQueuePriorityVeryHigh = 8//优先级非常高
};
设置操作完成后的回调block
@property (copy) void (^completionBlock)(void);
设置操作的优先级
@property double threadPriority;
设置操作的名称
@property (copy) NSString *name;
操作之间的依赖关系
依赖关系和优先级的作用很像，却也不同。如果一个操作A依赖于另一个操作B，那么只有当B操作完成后，A操作才会执行。
添加一个依赖：
- (void)addDependency:(NSOperation *)op;
删除一个依赖
- (void)removeDependency:(NSOperation *)op;
原则上说，一个操作对象的依赖可以添加多个，并且当所有依赖都执行完成后才会执行这个操作。
2、NSInvocationOperation(调度操作)
@interface NSInvocationOperation : NSOperation
这个类执行的操作是与调用它的线程同步的
根据选择器创建一个对象
- (instancetype)initWithTarget:(id)target selector:(SEL)sel object:(id)arg;
通过Invocation创建一个对象
- (instancetype)initWithInvocation:(NSInvocation *)inv;
3、NSBlockOperation(块操作)
@interface NSBlockOperation : NSOperation
可以异步的执行多个block，当所有的block都完成时，这个操作才算完成。
初始化方法：
+ (instancetype)blockOperationWithBlock:(void (^)(void))block;
定义操作并添加到队列:
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
[self operationAction:@"Block Operation"];
}];
[self.myQueue addOperation:op];
在操作中添加block
- (void)addExecutionBlock:(void (^)(void))block;
添加进去的block的数组
@property (readonly, copy) NSArray *executionBlocks;
示例如下：
NSBlockOperation * opera = [NSBlockOperation blockOperationWithBlock:^{
for (int i=0; i<10; i++) {
NSLog(@"%@=%d",[NSThread currentThread],i);
}
}];
[opera addExecutionBlock:^{
for (int i=0; i<10; i++) {
NSLog(@"%@=%d",[NSThread currentThread],i);
}
}];
[opera start];
两个block块的执行是异步的
NSOperation小结:
从本质上看,操作队列的性能会比GCD略低,不过,大多数情况下这点负面影响可以忽略不计.操作队列是并发编程的首选工具.
在这里,推荐一个非常好用的第三方编程框架AFN,底层用GCD开发,开发的接口是NSOperation的.
多线程中得循环引用问题:
如果self对象持有操作对象的引用,同时操作对象当中又直接访问了self时,才会造成循环引用.
单纯在操作对象中使用self不会造成循环引用.
注意: 此时不要使用[weakSelf].
多线程中的资源共享问题:
并发编程中许多问题的根源就是在多线程中访问共享资源.资源可以是一个属性,一个对象,网络设备或者一个文件等.
在多线程中任何一个共享的资源都可能是一个潜在的冲突点,必须精心设计以防止这种冲突的发生.
为了保证性能,atomic仅针对属性的setter方法做了保护.
争抢共享资源时,如果涉及到属性的getter方法,可以使用互斥锁(@synchronized)可以保证属性在多个线程之间的读写都是安全的.
无论是atomic还是@synchronized ,使用的代价都是高昂的.
建议:
多线程是并发执行多个任务提高效率的,如果可能,应该在线程中避免争抢共享资源.
正是出于性能的考虑,UIKit中的绝大多数类都不是线程安全的,因此,苹果公司要求:更新UI相关的操作,应该在主线程中执行.
4、NSOperationQueue操作队列
@interface NSOperationQueue : NSObject
NSOperationQueue是操作队列类，操作默认的执行方式是串行的，尽管NSBlockOperation中的block块间是并行执行的，但其和外部操作依然是串行的。
创建队列：
NSOperationQueue * queue = [[NSOperationQueue alloc]init];
在操作队列中添加一个操作任务：
- (void)addOperation:(NSOperation *)op;
在队列中插入一组操作任务，后面的参数设置是否队列中得任务都执行完成后再执行这一组操作：
- (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait;
在队列中添加一个block操作
- (void)addOperationWithBlock:(void (^)(void))block;
获取操作队列中的所有操作的数组
@property (readonly, copy) NSArray *operations;
获取操作队列中操作的个数
@property (readonly) NSUInteger operationCount;
设置队列最大并行操作数量
@property NSInteger maxConcurrentOperationCount;
设置是否暂停队列任务执行
@property (getter=isSuspended) BOOL suspended;
设置队列名字
@property (copy) NSString *name;
设置队列的优先级别（iOS8后支持）
@property NSQualityOfService qualityOfService;
取消队列中所有操作任务
- (void)cancelAllOperations;
阻塞当前线程，直到队列中所有任务完成
- (void)waitUntilAllOperationsAreFinished;
获取当前执行的队列
+ (NSOperationQueue *)currentQueue;
获取主线程中的操作队列
+ (NSOperationQueue *)mainQueue;
队列中操作的执行顺序法则
1、决定于依赖关系，只有当这个操作的依赖全部执行完成后，它才会被执行。
2、影响于优先级，优先级高的会先执行。
三、GCD基本思想
GCD的基本思想就是将操作S放在队列S中去执行.
1> 操作使用Blocks定义;
2> 队列负责调度任务执行所在的线程以及具体的执行时间;
3> 队列的特点是先进先出(FIFO)的,新添加至队列的操作都会排在队尾.
提示:
GCD的函数都是以dispatch(分派/调度)开头的.
队列:
dispatch_queue_t
串行队列: 队列中的任务只会顺序执行;
并行队列: 队列中的任务通常会并发执行.
操作:
dispatch_async 异步操作,会并发执行,无法确定任务的执行顺序;
dispatch_sync 同步操作,会依次顺序执行,能够决定任务的执行顺序.
队列不是线程,也不表示对应的CPU.队列就是负责调度的.多线程技术的目的,就是为了在一个CPU上实现快速切换!
在串行队列中:
同步操作不会新建线程,操作顺序执行(没用!);
异步操作会新建线程,操作顺序执行(非常有用!) (应用场景:既不影响主线程,又需要顺序执行的操作).
在并行队列中:
同步操作不会新建线程,操作顺序执行;
异步操作会新建多个线程,操作无序执行(有用,容易出错),队列前如果有其他任务,会等待前面的任务完成之后再执行.应用场景:既不影响主线程,又不需要顺序执行的操作.
全局队列:
全局队列是系统的,直接拿过来(GET)用就可以,与并行对立类似,但调试时,无法确认操作所在队列.
主队列:
每一个应用程序都对应唯一一个主队列,直接GET即可,在多线程开发中,使用主队列更新UI;
注意:
主队列中的操作都应该在主线程上顺序执行,不存在异步的概念.
如果把主线程中的操作看作是一个大的Block,那么除非主线程被用户杀掉,否则永远不会结束.所以主队列中添加的同步操作永远不会被执行,会死锁.
不同队列中嵌套同步操作dispatch_sync的结果:
// 全局队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 并行队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_queue_create("m.baidu.com", DISPATCH_QUEUE_CONCURRENT);
// 串行队列，会死锁，但是会执行嵌套同步操作之前的代码
dispatch_queue_t q = dispatch_queue_create("m.baidu.com", DISPATCH_QUEUE_SERIAL);
// 直接死锁
dispatch_queue_t q = dispatch_get_main_queue();
同步操作dispatch_sync的应用场景:
阻塞并行队列的执行，要求某一操作执行后再进行后续操作，如用户登录.
确保块代码之外的局部变量确实被修改.
[NSThread sleepForTimeInterval:2.0f] 通常在多线程调试中用于模拟耗时操作,在发布的应用程序中，不要使用此方法！
无论什么队列和什么任务,线程的创建和回收都不需要程序员参与.线程的创建回收工作是由队列负责的.
GCD优点:
1> 通过GCD,开发者不用再直接跟线程打交道,只需要向队列中添加代码块即可.
2> GCD在后端管理着一个线程池,GCD不仅决定着代码块将在哪个线程被执行,它还根据可用的系统资源对这些线程进行管理,从而让开发者从线程管理的工作中解放出来;通过集中的管理线程,缓解大量线程被创建的问题.
3> 使用GCD,开发者可以将工作考虑为一个队列,而不是一堆线程,这种并行的抽象模型更容易掌握和使用.
GCD队列:
GCD公开有5个不同的队列:运行在主线程中的主队列,3个不同优先级的后台队列以及一个优先级更低的后台队列(用于I/O).
自定义队列:串行和并行队列.自定义队列非常强大,建议在开发中使用.
在自定义队列中被调度的所有Block最终都将被放入到系统的全局队列中和线程池中.
提示:
不建议使用不同优先级的队列,因为如果设计不当,可能会出现优先级反转,即低优先级的操作阻塞高优先级的操作.
GCD的调度机制
GCD机制中一个很重要的概念是调度队列，我们对线程的操作实际上是由调度队列完成的。我们只需要将要执行的任务添加到合适的调度队列中即可。
1、调度队列的类型
调度队列有三种类型：
（1）主队列
其中的任务在主线程中执行，因为其会阻塞主线程，所以这是一个串行的队列。
dispatch_get_main_queue();
（2）全局并行队列
队列中任务的执行方式是严格按照先进先出的模式进行了。如果是串行的队列，则当一个任务结束后，才会开启另一个任务，如果是并行队列，则任务的开启顺序是和添加顺序一致的。系统为iOS应用自动创建了四个全局共享的并发队列。
//1. 获取全局队列
dispatch_get_global_queue(long identifier, unsigned long flags);
//第一个参数是线程的优先级,第二个参数暂时没有用，永远给0
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
其中第一个参数是这个队列的identifier，系统的四个全局队列默认的优先级不同，这个参数可填的定义如下：
#define DISPATCH_QUEUE_PRIORITY_HIGH 2//优先级最高的全局队列
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0//优先级中等的全局队列
#define DISPATCH_QUEUE_PRIORITY_LOW (-2)//优先级低的全局队列
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN//后台的全局队列 优先级最低
这个函数的第二个参数，按照官方文档的说法是有待未来使用，现在我们都填0即可。
（3）自定义队列
上面的两种队列都是系统为我们创建好的，我们只需要获取到他们，将任务添加即可。当然，我们可可以创建我们自己的队列，包括串行的和并行的。使用如下方法创建：
dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);
dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL);
参数一：这个队列的名字，参数二：队列类型
DISPATCH_QUEUE_SERIAL或者NULL//串行队列
DISPATCH_QUEUE_CONCURRENT//并行队列
添加任务到队列中
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);//同步
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);//异步
2、队列调度机制的更多技巧
（1）使用队列组
如果有这样三个任务，A与B是没有关系的，他们可以并行执行，C必须在A,B结束之后才能执行，当然，实现这样的逻辑并不困难，使用KVO就可以实现，但是使用队列组处理这样的逻辑，代码会更加清晰简单。
可以使用dispatch_group_create()创建一个队列组，使用如下函数将队列添加到队列组中：
dispatch_group_async(dispatch_group_t group,
dispatch_queue_t queue,
dispatch_block_t block);
队列组中的队列是异步执行的，示例如下：
- (IBAction)test {
//创建一个队列组
dispatch_group_t group = dispatch_group_create();
//创建一个异步队列
dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT);
//添加队列任务到队列组
dispatch_group_async(group, queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"group1:%@:%d",[NSThread currentThread], i);
}
});
dispatch_group_async(group, queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"group2%@:%d",[NSThread currentThread], i);
}
});
//队列组任务执行完后执行的任务
dispatch_group_notify(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
for (int i = 0; i < 10; i++) {
NSLog(@"over:%@:%d", [NSThread currentThread], i);
}
});
//阻塞线程直到队列任务完成
//dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
for (int i = 0; i < 10; i++) {
NSLog(@"finish:%@:%d", [NSThread currentThread], i);
}
}
（2）循环机制
一开始我们就提到，GCD相比NSOperation的优势在于多核心的应用，更深得挖掘出了硬件的性能。GCD在多核方面的一个明显的特点就是循环机制。
dispatch_apply(10, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(size_t i) {
NSLog(@"apply%@:%zu", [NSThread currentThread], i);
});
dispatch_apply 和 dispatch_apply_f是同步函数,作用是把指定次数指定的block添加到queue中,会阻塞当前线程直到所有循环迭代执行完成。当提交到并发queue时,循环迭代的执行顺序是不确定的
（3）消息传递机制
dispatch_source_t类型的对象可以用来传递和接受某个消息，然后执行block方法，示例如下：
- (void)viewDidLoad
{
[super viewDidLoad];
//创建一个数据对象，DISPATCH_SOURCE_TYPE_DATA_ADD的含义表示数据变化时相加
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());
//创建接收数据变化的句柄
dispatch_source_set_event_handler(source, ^{
NSLog(@"%lu", dispatch_source_get_data(source));
});
//启动
dispatch_resume(source);
//设置数据
dispatch_source_merge_data(source, 1);
//这步执行完之后会执行打印方法
}
（4）发送和等待信号
GCD中还有一个重要的概念是信号量。它的用法法消息的传递有所类似，通过代码来解释：
//创建一个信号，其中的参数为信号的初始值
dispatch_semaphore_t singer = dispatch_semaphore_create(0);
//发送信号，使信号量+1
dispatch_semaphore_signal(singer);
//等待信号，当信号量大于0时执行后面的方法，否则等待，第二个参数为等待的超时时长，下面设置的为一直等待
dispatch_semaphore_wait(singer,DISPATCH_TIME_FOREVER);
NSLog(@"123");
//通过发送信号，可以试信号量+1，每次执行过等待信号后，信号量会-1；如此，我们可以很方便的控制不同队列中方法的执行流程。
（5）挂起和开启任务队列
GCD还提供了暂停与开始任务的方法，使用
void dispatch_suspend(dispatch_object_t object);
可以将队列或者队列组进行暂时的挂起，使用
void dispatch_resume(dispatch_object_t object);
将队列或者队列组重新开启。
需要注意的是，暂停队列时，队列中正在执行的任务并不会被中断，会挂起未开启的任务。
3、关于内存管理
GCD虽然是基于C语言封装的框架，使用了面向对象的思想。因此，它的内存管理是需要我们注意的，不论是ARC或者MRC，我们都应该手动去处理这些对象。还好，GCD的内存管理思路和Object—C是兼容的，我们使用dispatch_retain()和dispatch_release()来将引用对象的计数进行加减。这一点十分重要，切记切记。
扫一扫
619
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
