012-iOS之多线程管理

前言:

•进程

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

•线程

线程是进程中一个独立的执行路径(控制单元)
一个进程中至少包含一条线程,即主线程
可以将耗时的执行路径(如:网络请求)放在其他线程中执行
创建线程:就是开启一条新的执行路径,负责程序中指定的代码运行,与主线程中的代码实现同时运行(新建一条执行路径 512K 不能杀掉一个线程!但是可以暂停、休眠
•优势
(1)充分发挥多核处理器优势,将不同线程任务分配给不同的处理器,真正进入“并行运算”状态
(2)将耗时的任务分配到其他线程执行,由主线程负责统一更新界面会使应用程序更加流畅,用户体验更好
(3)当硬件处理器的数量增加,程序会运行更快,而程序无需做任何调整
•弊端
新建线程会消耗内存空间和CPU时间,线程太多会降低系统的运行性能
•误区
多线程技术是为了并发执行多项任务,不会提高单个算法本身的执行效率 

简介

每一个iOS程序都有一个专门用于更新显示UI界面、处理用户触摸事件的主线程,如果将其他太耗时的操作放在主线程中执行,很容易照成主线程的阻塞,而导致程序出现卡机的现象,带来极差的用户体验,为了避免这个现象的发生,我们通常将其他耗时的操作放到其他线程中去,增加运行效果的最好方法。下面我们将介绍一下iOS的三种多线程编程:

1.NSThread

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

这种方法需要管理线程的生命周期、同步、加锁问题,会导致一定的性能开销,

2.NSOperation和NSOperationQueue

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

NSOperation以面向对象的方式封装了需要执行的操作,然后可以将这个操作放到一个NSOperationQueue中去异步执行。不必关心线程管理、同步等问题

3.Grand Centeral Dispatch

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

简称GCD,iOS4才开始支持,是纯C语言的API。自iPad2开始,苹果设备开始有了双核CPU,为了充分利用这2个核,GCD提供了一些新特性来支持多核并行编程

提示:iOS的开发者,需要了解三种多线程技术的基本使用,因为在实际开发中会根据实际情况选择不同的多线程技术 

NSThread

一、获取当前线程
NSThread *current = [NSThread currentThread]; 
 
二、获取主线程
NSThread *main = [NSThread mainThread];
NSLog(@"主线程:%@", main);
打印结果是:
2014-08-25 09:13:33.599 thread[7493:c07] 主线程:<NSThread: 0x23343e0>{name = (null), num = 1}num相当于线程的id,主线程的num是为1的

三、NSThread的创建
1.动态方法
- (id)initWithTarget:(id)target selector:(SEL)selector object:(id)argument; // 在第2行创建了一条新线程,然后在第4行调用start方法启动线程,线程启动后会调用self的run:方法,并且将@"hb"作为方法参数
1 // 初始化线程
2 NSThread *thread = [[[NSThread alloc] initWithTarget:self selector:@selector(run:) object:@"hb"] autorelease];
3 // 开启线程
4 [thread start];假如run:方法是这样的:

1 - (void)run:(NSString *)string {
2     NSThread *current = [NSThread currentThread];
3     NSLog(@"执行了run:方法-参数:%@,当前线程:%@", string, current);
4 }
打印结果为:
2014-08-25 09:20:21.102 thread[7542:3e13] 执行了run:方法-参数:mj,当前线程:<NSThread: 0x8495e3d0>{name = (null), num = 3}可以发现,这条线程的num值为3,说明不是主线程,主线程的num为1

2.静态方法
+ (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(id)argument;[NSThread detachNewThreadSelector:@selector(run:) toTarget:self withObject:@"hb"]; // 执行完上面代码后会马上启动一条新线程,并且在这条线程上调用self的run:方法,以@"hb"为方法参数
 
3.隐式创建线程
[self performSelectorInBackground:@selector(run:) withObject:@"hb"]; // 会隐式地创建一条新线程,并且在这条线程上调用self的run:方法,以@"hb"为方法参数
 
四、暂停当前线程
[NSThread sleepForTimeInterval:2];
NSDate *date = [NSDate dateWithTimeInterval:2 sinceDate:[NSDate date]];  
[NSThread sleepUntilDate:date]; // 上面两种做法都是暂停当前线程2秒

五、线程的其他操作
1.在指定线程上执行操作
[self performSelector:@selector(run) onThread:thread withObject:nil waitUntilDone:YES]; // 上面代码的意思是在thread这条线程上调用self的run方法
// 最后的YES代表:上面的代码会阻塞,等run方法在thread线程执行完毕后,上面的代码才会通过
2.在主线程上执行操作
[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES]; // 在主线程调用self的run方法
3.在当前线程执行操作
[self performSelector:@selector(run) withObject:nil]; // 在当前线程调用self的run方法

六、优缺点
1.优点:NSThread比其他多线程方案较轻量级,更直观地控制线程对象
2.缺点:需要自己管理线程的生命周期,线程同步。线程同步对数据的加锁会有一定的系统开销

 NSOperation和NSOperationQueue

•简介
(1)NSOperationQueue(操作队列)是由GCD提供的队列模型的Cocoa抽象,是一套Objective-C的API
(2)GCD提供了更加底层的控制,而操作队列则在GCD之上实现了一些方便的功能,这些功能对于开发者而言通常是最好最安全的选择
 
•队列及操作
1.NSOperationQueue有两种不同类型的队列:主队列和自定义队列
2.主队列运行在主线程上
3.自定义队列在后台执行
4.队列处理的任务是NSOperation的子类
(1)NSInvocationOperation
(2)NSBlockOperation
 
•基本使用步骤
(1)定义操作队列
(2)定义操作
(3)将操作添加到队列
提示:一旦将操作添加到队列,操作就会立即被调度执行

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];
•小结需要准备一个被调度的方法,并且能够接收一个参数

NSBlockOperation(块操作)

•定义操作并添加到队列
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
    [self operationAction:@"Block Operation"];
}];
•将操作添加到队列
[self.myQueue addOperation:op];
•小结NSBlockOperation比NSInvocationOperation更加灵活
 
设置操作的依赖关系
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];
// [op1 addDependency:op3]; //会造成循环依赖
[self.myQueue addOperation:op1];
[self.myQueue addOperation:op2];
[[NSOperationQueue mainQueue] addOperation:op3];

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

设置同时并发的线程数量

[self.myQueue setMaxConcurrentOperationCount:2];
// 设置同时并发的线程数量能够有效地降低CPU和内存的开销 这一功能用GCD不容易实现
for (int i = 0; i < 10; ++i) {
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        [self operationAction:@(i)];
    }];
    
    [self.myQueue addOperation:op];
}
 
NSOperation小结
1>.从本质上来看,操作队列的性能会比GCD略低,不过,大多数情况下这点负面影响可以忽略不计,操作队列是并发编程的首选工具
ps:AFN,底层用GCD开发,开发的接口是NSOperation的

GCD---Grand Centeral Dispatch (大中央调度)

 

GCD小结

 

(1)通过GCD,开发者不用再直接跟线程打交道,只需要向队列中添加代码块即可

 

(2)GCD在后端管理着一个线程池,GCD不仅决定着代码块将在哪个线程被执行,它还根据可用的系统资源对这些线程进行管理。从而让开发者从线程管理的工作中解放出来,通过集中的管理线程,缓解大量线程被创建的问题

 

(3)使用GCD,开发者可以将工作考虑为一个队列,而不是一堆线程,这种并行的抽象模型更容易掌握和使用

 

GCD的队列

 

(1)GCD公开有5个不同的队列:运行在主线程中的主队列,3 个不同优先级的后台队列,以及一个优先级更低的后台队列(用于 I/O)

 

(2)自定义队列:串行和并行队列。自定义队列非常强大,建议在开发中使用。在自定义队列中被调度的所有Block最终都将被放入到系统的全局队列中和线程池中

 

(3)提示:不建议使用不同优先级的队列,因为如果设计不当,可能会出现优先级反转,即低优先级的操作阻塞高优先级的操作

 

 

 

•GCD的基本思想是就将操作s放在队列s中去执行
(1)操作使用Blocks定义
(2)队列负责调度任务执行所在的线程以及具体的执行时间
(3)队列的特点是先进先出(FIFO)的,新添加至对列的操作都会排在队尾
 
•提示
GCD的函数都是以dispatch(分派、调度)开头的
•队列(dispatch_queue_t)
串行队列,队列中的任务只会顺序执行
并行队列,队列中的任务通常会并发执行
•操作
dispatch_async 异步操作,会并发执行无法确定任务的执行顺序
dispatch_sync 同步操作,会依次顺序执行能够决定任务的执行顺序
 
ps:队列不是线程?也不表示对应的CPU 队列就是负责调度的!谁空闲,就把任务给谁!多线程技术的目的,就是为了在一个CPU上实现快速切换!
 
•串行队列
dispatch_queue_t q = dispatch_queue_create("testQueue", DISPATCH_QUEUE_SERIAL); // 队列名称在调试时辅助

dispatch_sync(q, ^{
    NSLog(@"串行同步 %@", [NSThread currentThread]);
});  // 同步操作不会新建线程、操作顺序执行(没用!)

dispatch_async(q, ^{
    NSLog(@"串行异步 %@", [NSThread currentThread]);
});  // 异步操作会新建线程、操作顺序执行(非常有用!)

场景:既不影响主线程,又需要顺序执行的操作!

•串行队列

dispatch_queue_t q = dispatch_queue_create("testQueue", DISPATCH_QUEUE_CONCURRENT); // 队列名称在调试时辅助
dispatch_sync(q, ^{
    NSLog(@"并行同步 %@", [NSThread currentThread]);
});  // 同步操作不会新建线程、操作顺序执行

dispatch_async(q, ^{
    NSLog(@"并行异步 %@", [NSThread currentThread]);
});    // 异步操作会新建多个线程、操作无序执行(有用,容易出错!)队列前如果有其他任务,会等待前面的任务完成之后再执行
场景:既不影响主线程,又不需要顺序执行的操作!

•全局队列

dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);   //全局队列是系统的,直接拿过来(GET)用就可以与并行队列类似,但调试时,无法确认操作所在队列

dispatch_async(q, ^{
    NSLog(@"全局异步 %@ %d", [NSThread currentThread], i);
});  // 会新建多个线程、操作无序执行队列前如果有其他任务,会等待前面的任务完成之后再执行

dispatch_sync(q, ^{
    NSLog(@"全局同步 %@ %d", [NSThread currentThread], i);
});  // 同步操作不会新建线程、操作顺序执行

•主队列

dispatch_queue_t q = dispatch_get_main_queue();
// 每一个应用程序对应唯一一个主队列,直接GET即可在多线程开发中,使用主队列更新UI

dispatch_async(q, ^{
    NSLog(@"主队列异步 %@", [NSThread currentThread]);
});
// 主队列中的操作都应该在主线程上顺序执行的,不存在异步的概念

dispatch_sync(q, ^{
    NSLog(@"主队列同步 %@", [NSThread currentThread]);
});   // 如果把主线程中的操作看成一个大的Block,那么除非主线程被用户杀掉,否则永远不会结束主队列中添加的同步操作永远不会被执行,会死锁

不同队列中嵌套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]);
    });
});

dispatch_sync的应用场景

1>阻塞并行队列的执行,要求某一操作执行后再进行后续操作,如用户登录
2>确保块代码之外的局部变量确实被修改
dispatch_queue_t q = dispatch_queue_create("com.whblap.test", 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]);

});

ps:

串行队列,同步任务,不需要新建线程
串行队列,异步任务,需要一个子线程,线程的创建和回收不需要程序员参与! “是最安全的一个选择”串行队列只能创建!
并行队列,同步任务,不需要创建线程
并行队列,异步任务,有多少个任务,就开N个线程执行,
无论什么队列和什么任务,线程的创建和回收不需要程序员参与。
线程的创建回收工作是由队列负责的
“并发”编程,为了让程序员从负责的线程控制中解脱出来!只需要面对队列和任务!

 

 

 
 
 
 

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。