2015/12/09
Day 46
今天学习多线程
多线程的优缺点
新建线程会消耗内存空间和 CPU时间,线程太多会降低系统的运行性能
iOS 的三种多线程技术
GCD 基本思想
GCD 的函数都是以dispatch( 分派、调度) 开头的
dispatch_queue_t
dispatch_async异步操作,会并发执行,无法确定任务的执行顺序
dispatch_sync同步操作,会依次顺序执行,能够决定任务的执行顺序
下面是演练 GCD的OC代码
串行队列(一个接一个,排队跑步,保持队形)
1 NSLog(@"%@", [NSThread currentThread]); 2 dispatch_queue_t q = dispatch_queue_create(“yu1”, DISPATCH_QUEUE_SERIAL); 3 // 非ARC开发时,千万别忘记release 4 // dispatch_release(q); 5 6 // 串行行队列的同步任务,同样会在主线程上运行 7 // 提示:在开发中极少用 8 for (int i = 0; i < 5; ++i) { 9 // 同步任务顺序执行 10 dispatch_sync(q, ^{ 11 NSLog(@"%@ %d", [NSThread currentThread], i); 12 }); 13 } 14 15 for (int i = 0; i < 5; ++i) { 16 // 异步任务,并发执行,但是如果在串行队列中,仍然会依次顺序执行 17 dispatch_async(q, ^{ 18 // [NSThread currentThread] 可以在开发中,跟踪当前线程 19 // num = 1,表示主线程 20 // num = 2,表示第2个子线程。。。 21 NSLog(@"%@ %d", [NSThread currentThread], i); 22 }); 23 }
打印结果如下
然后是 并行队列 (并排跑,类似于赛跑)
1 NSLog(@"%@", [NSThread currentThread]); 2 // 特点:没有队形,执行顺序程序员不能控制! 3 // 应用场景:并发执行任务,没有先后顺序关系 4 // 并行队列容易出错!并行队列不能控制新建线程的数量! 5 dispatch_queue_t q = dispatch_queue_create("yu2", DISPATCH_QUEUE_CONCURRENT); 6 7 for (int i = 0; i < 10; ++i) { 8 // 异步任务 9 dispatch_async(q, ^{ 10 // [NSThread currentThread] 可以在开发中,跟踪当前线程 11 // num = 1,表示主线程 12 // num = 2,表示第2个子线程。。。 13 NSLog(@"%@ %d", [NSThread currentThread], i); 14 }); 15 } 16 17 for (int i = 0; i < 10; ++i) { 18 // 同步任务顺序执行 19 dispatch_sync(q, ^{ 20 NSLog(@"%@ %d", [NSThread currentThread], i); 21 }); 22 }
控制台打印
全局队列(苹果为了方便多线程的设计,提供一个全局队列,供所有的 APP共同使用)
1 // 全局队列与并行队列的区别 2 // 1> 不需要创建,直接GET就能用 3 // 2> 两个队列的执行效果相同 4 // 3> 全局队列没有名称,调试时,无法确认准确队列 5 NSLog(@"%@", [NSThread currentThread]); 6 // 优先级在开发中一般用DISPATCH_QUEUE_PRIORITY_DEFAULT 7 dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 8 9 for (int i = 0; i < 5; ++i) { 10 // 同步任务顺序执行 11 dispatch_sync(q, ^{ 12 NSLog(@"%@ %d", [NSThread currentThread], i); 13 }); 14 } 15 16 for (int i = 0; i < 5; ++i) { 17 dispatch_async(q, ^{ 18 // [NSThread currentThread] 可以在开发中,跟踪当前线程 19 // num = 1,表示主线程 20 // num = 2,表示第2个子线程。。。 21 NSLog(@"%@ %d", [NSThread currentThread], i); 22 }); 23 }
打印如下
主 ( 线程 ) 队列 ,保证操作在主线程上执行
1 // 每一个应用程序都只有一个主线程 2 // 为什么需要在主线程上工作呢? 3 // 在iOS开发中,所有UI的更新工作,都必须在主线程上执行! 4 dispatch_queue_t q = dispatch_get_main_queue(); 5 6 // 主线程是有工作的,而且除非将程序杀掉,否则主线程的工作永远不会结束! 7 // 同步任务,阻塞了!!! 8 // dispatch_sync(q, ^{ 9 // NSLog(@"come here baby!"); 10 //}); 11 12 // 异步任务,在主线程上运行,同时是保持队形的 13 for (int i = 0; i < 5; ++i) { 14 dispatch_async(q, ^{ 15 NSLog(@"%@ - %d", [NSThread currentThread], i); 16 }); 17 }
注意阻塞情况,打印如下
接下来用 swift将上面 4个 demo演练了一遍
串行队列(一个接一个,排队跑步,保持队形)
let q = dispatch_queue_create("串行队列1", DISPATCH_QUEUE_SERIAL) print("串行队列,同步任务") for i in 0 ..< 5 { //同步任务,顺序执行,同一线程上执行(还是在主线程) dispatch_sync(q, { () -> Void in print("/(NSThread.currentThread()) - /(i)") }) } print("串行队列,异步任务") for i in 0 ..< 5 { //异步任务,开一个子线程并发执行,但是如果在串行队列中,仍然会依次顺序执行 // num = 1,表示主线程 // num = 2,表示第2个子线程。。。 dispatch_async(q, { () -> Void in print("/(NSThread.currentThread()) - /(i)") }) }
控制台打印
并行队列 (并排跑,类似于赛跑)
// 特点:没有队形,执行顺序程序员不能控制! // 应用场景:并发执行任务,没有先后顺序关系 // 并行队列容易出错!并行队列不能控制新建线程的数量! let q = dispatch_queue_create("并行队列1", DISPATCH_QUEUE_CONCURRENT) print("并行队列,异步任务") for i in 0 ..< 5 { //异步任务,随机乱序,并且有N个子线程 dispatch_async(q, { () -> Void in print("/(NSThread.currentThread()) - /(i)") }) } print("并行队列,同步任务") for i in 0 ..< 5 { //同步任务,顺序执行,同一线程上执行(还是在主线程) dispatch_sync(q, { () -> Void in print("/(NSThread.currentThread()) - /(i)") }) }
控制台打印
全局队列(苹果为了方便多线程的设计,提供一个全局队列,供所有的 APP共同使用)
// 全局队列与并行队列的区别 // 1> 不需要创建,直接GET就能用 // 2> 两个队列的执行效果相同 // 3> 全局队列没有名称,调试时,无法确认准确队列 // 优先级在开发中一般用DISPATCH_QUEUE_PRIORITY_DEFAULT let q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) print("全局队列,异步任务") for i in 0 ..< 5 { //异步任务,随机乱序,并且有N个子线程 dispatch_async(q, { () -> Void in print("/(NSThread.currentThread()) - /(i)") }) } print("全局队列,同步任务") for i in 0 ..< 5 { //同步任务,顺序执行,同一线程上执行(还是在主线程) dispatch_sync(q, { () -> Void in print("/(NSThread.currentThread()) - /(i)") }) }
控制台打印
主 ( 线程 ) 队列 ,保证操作在主线程上执行
// 每一个应用程序都只有一个主线程 // 为什么需要在主线程上工作呢? // 在iOS开发中,所有UI的更新工作,都必须在主线程上执行! let q = dispatch_get_main_queue() print("主队列,异步任务") for i in 0 ..< 5 { // 异步任务,在主线程上运行,同时是保持队形的 dispatch_async(q, { () -> Void in print("/(NSThread.currentThread()) - /(i)") }) } // print("主队列,同步任务,阻塞") // // 主线程是由工作的,而且除非将程序杀掉,否则主线程的工作永远不会结束! // // 阻塞了!!! // dispatch_sync(q, { () -> Void in // print("come on baby") // })
控制台打印
dispatch_sync 的应用场景
1 dispatch_queue_t q = dispatch_queue_create(“yu3”, DISPATCH_QUEUE_CONCURRENT); 2 __block BOOL logon = NO; 3 dispatch_sync(q, ^{ 4 NSLog(@"模拟耗时操作 %@", [NSThread currentThread]); 5 [NSThread sleepForTimeInterval:2.0f];//通常在多线程调试中用于模拟耗时操作, 在发布的应用程序中,不要使用此方法! 6 NSLog(@"模拟耗时完成 %@", [NSThread currentThread]); 7 logon = YES; 8 }); 9 10 dispatch_async(q, ^{ 11 NSLog(@"登录完成的处理 %@", [NSThread currentThread]); 12 });
GCD 小结
串行队列,同步任务,不需要新建线程
串行队列,异步任务,需要一个子线程,线程的创建和回收不需要程序员参与!
“是最安全的一个选择 ”串行队列只能创建一个子线程
并行队列,同步任务,不需要创建线程
并行队列,异步任务,有多少个任务,就开 N个线程执行,
无论什么队列和什么任务,线程的创建和回收不需要程序员参与。
线程的创建回收工作是由队列负责的
“并发 ”编程,为了让程序员从负责的线程控制中解脱出来!只需要面对队列和任务!
GCD 队列示意图
NSOperation & NSOperationQueue
NSOperation 的基本使用步骤
提示:一旦将操作添加到队列,操作就会立即被调度执行
NSInvocationOperation( 调度操作 )
1 //定义队列 2 self.myQueue = [[NSOperationQueue alloc] init]; 3 //操作调用的方法 4 - (void)operationAction:(id)obj 5 { 6 NSLog(@"%@ - obj : %@", [NSThread currentThread], obj); 7 } 8 //定义操作并添加到队列 9 NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationAction:) object:@(i)]; 10 [self.myQueue addOperation:op]; 11 //小结:需要准备一个被调度的方法,并且能够接收一个参数,使用起来不方便
NSBlockOperation
1 //定义操作并添加到队列 2 NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{ 3 [self operationAction:@"Block Operation"]; 4 }]; 5 //将操作添加到队列 6 [self.myQueue addOperation:op];
设置操作的依赖关系(顺序执行)
1 NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{ 2 NSLog(@"%@ - 下载图片", [NSThread currentThread]); 3 }]; 4 NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{ 5 NSLog(@"%@ - 添加图片滤镜", [NSThread currentThread]); 6 }]; 7 NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{ 8 NSLog(@"%@ - 更新UI", [NSThread currentThread]); 9 }]; 10 [op2 addDependency:op1]; 11 [op3 addDependency:op2]; 12 [self.myQueue addOperation:op1]; 13 [self.myQueue addOperation:op2]; 14 [[NSOperationQueue mainQueue] addOperation:op3];
提示:利用 addDependency 可以指定操作之间的彼此依赖关系 ( 执行先后顺序 )
注意:不要出现循环依赖!
NSOperationQueue 还可以设置同时并发的线程数量
[self.myQueue setMaxConcurrentOperationCount:3];
设置同时并发的线程数量能够有效地降低 CPU和内存的开销
这一功能用 GCD不容易实现
Run Loop
(1) Run Loop提供了一种异步执行代码的机制,不能并行执行任务
(2) 在主队列中, Main Run Loop直接配合任务的执行,负责处理 UI事件、计时器,以及其它内核相关事件
(3) Run Loop的主要目的是保证程序执行的线程不会被系统终止
Run Loop 的工作特点
主线程和其他线程中的 Run Loop
多线程中的资源共享
并发编程中许多问题的根源就是在多线程中访问共享资源。资源可以是一个属性、一个对象、网络设备或者一个文件等
在多线程中任何一个共享的资源都可能是一个潜在的冲突点,必须精心设计以防止这种冲突的发生
为了保证性能, atomic仅针对属性的 setter方法做了保护
而争抢共享资源时,如果涉及到属性的 getter方法,可以使用互斥锁 @synchronized可以保证属性在多个线程之间的读写都是安全的
无论是 atomic还是 @synchronized,使用的代价都是高昂的,不建议使用
建议:多线程是并发执行多个任务提高效率的,如果可能,应该在线程中避免争抢共享资源
正是出于性能的考虑, UIKit中的绝大多数的类都不是线程安全的,因此,苹果公司要求:更新 UI相关的操作,应该在主线程中执行
单例模式
音频播放,背景音乐!
硬件资源:加速器、[UIScreen mainScreen]
下面是实现单例模式的 OC代码
DemoObj.h
1 @interface DemoObj : NSObject 2 3 + (instancetype)sharedDemoObj; 4 5 @end
DemoObj.m
1 @implementation DemoObj 2 /** 3 1. 重写allocWithZone,用dispatch_once实例化一个静态变量(dispatch_once是线程安全的,能够做到在多线程的环境下Block中的代码只会被执行一次) 4 2. 写一个+sharedXXX方便其他类调用 5 */ 6 // 在OC中,所有对象的内存空间的分配,最终都会调用allocWithZone方法 7 // 如果要做单例,需要重写此方法 8 // GCD提供了一个方法,专门用来创建单例的 9 + (instancetype)allocWithZone:(struct _NSZone *)zone { 10 static DemoObj *result; 11 static dispatch_once_t onceToken; 12 dispatch_once(&onceToken, ^{ 13 result = [super allocWithZone:zone]; 14 }); 15 return result; 16 } 17 18 + (instancetype)sharedDemoObj { 19 return [[self alloc] init]; 20 } 21 @end
Swift 代码
class Singleton: NSObject { internal class func sharedInstance() -> Singleton { struct Static { static var onceToken : dispatch_once_t = 0 static var instance : Singleton? = nil } dispatch_once(&Static.onceToken) { Static.instance = Singleton() } return Static.instance! } }
单例小结
优点 : 可以阻止其他对象实例化单例对象的副本,从而确保所有对象都访问唯一实例
缺点 : 单例对象一旦建立,对象指针是保存在静态区的,单例对象在堆中分配的内存空间,会在应用程序终止后才会被释放
提示 : 只有确实需要唯一使用的对象才需要考虑单例模式,不要滥用单例
NSObject 的多线程方法
- (void)performSelectorInBackground:(SEL)aSelector withObject:(id)arg
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait
[NSThread currentThread]
[NSThread sleepForTimeInterval:2.0f];
使用简单,量级轻
不能控制线程的数量以及执行顺序
注意事项
NSObject 的多线程方法使用的是NSThread 的多线程技术
而NSThread 的多线程技术不会自动使用@autoreleasepool
在使用NSObject 或NSThread 的多线程技术时,如果涉及到对象分配,需要手动添加@autoreleasepool
复习一下autoreleasepool
iOS开发中的内存管理
自动释放池的工作原理
每个线程都需要有 @autoreleasepool,否则可能会出现内存泄漏,但是使用 NSThread多线程技术,并不会为后台线程创建自动释放池