六.线程之间的通信
- <1>.原子和非原子属性OC在定义属性时有
nonatomic和atomic两种选择
atomic：原子属性，为setter方法加锁（默认就是atomic）nonatomic：非原子属性，不会为setter方法加锁:避免资源消耗
- <2>.原子和非原子属性的选择
nonatomic和atomic对比atomic：线程安全，需要消耗大量的资源nonatomic：非线程安全，适合内存小的移动设备
- <3>.iOS开发的建议
- 所有属性都声明为
nonatomic - 尽量避免多线程抢夺同一块资源
- 尽量将加锁、资源抢夺的业务逻辑交给服务器端处理，减小移动客户端的压力
- <4>.什么叫做线程间通信?
答:在1个进程中，线程往往不是孤立存在的，多个线程之间需要经常进行通信
- <5>.线程间通信的体现
- (1).1个线程传递数据给另1个线程
- (2).在1个线程中执行完特定任务后，转到另1个线程继续执行任务
- <6>.线程间通信常用方法
举个例子:用UIImageView加载图片
//1.获取图片的路径 NSString *stringPath = @"http://h.hiphotos.baidu.com/image/h%3D360/sign=48771214b08f8c54fcd3c3290a282dee/c9fcc3cec3fdfc0375633742d03f8794a4c22635.jpg"; //开始时间(秒数,从1970年0点0时0分0秒开始算起) CFTimeInterval begin = CFAbsoluteTimeGetCurrent(); //2.根据图片的路径去下载图片 NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:stringPath]]; //结束时间 CFTimeInterval end = CFAbsoluteTimeGetCurrent(); NSLog(@"开始时间=%f 结束时间=%f 消耗时间==%f",begin,end,end -begin); //3.加载下载好的图片 self.picture.image = [UIImage imageWithData:data];
获取时间间隔的方式:
1.第一种获取时间 NSDate *begin = [NSDate date]; //根据图片的路径去下载图片 NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:stringPath]]; //结束时间 NSDate *end = [NSDate date]; NSLog(@"开始时间=%@ 结束时间=%@ 消耗时间==%f",begin,end,[end timeIntervalSinceDate:begin]); 2.第二种获取时间 //开始时间(秒数,从1970年0点0时0分0秒开始算起) CFTimeInterval begin = CFAbsoluteTimeGetCurrent(); //2.根据图片的路径去下载图片 NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:stringPath]]; //结束时间 CFTimeInterval end = CFAbsoluteTimeGetCurrent(); NSLog(@"开始时间=%f 结束时间=%f 消耗时间==%f",begin,end,end -begin);
- <7>.子线程下载图片,在主线程刷新UI
1.跳转刷新UI
[self performSelectorOnMainThread:@selector(refreshUI:) withObject:image waitUntilDone:YES]; /** * 刷新UI */ -(void)refreshUI:(UIImage *)image { //3.加载下载好的图片 self.picture.image = image; }
- 2.直接不跳转刷新UI
[self.picture performSelector:@selector(setImage:) onThread:[NSThread mainThread] withObject:image waitUntilDone:YES];
最后解释一下方法的最后一个参数waitUntilDone:YES或者NO的问题
YES:意思是刷新UI之后再走子线程之后的其他任务
NO:意思是主线程刷新的同时,其他线程也在执行任务
线程通信方式的demo 密码: 85x4
七.GCD
- <1> 什么是GCD ?
GCD全称是Grand Central Dispatch，可译为“牛逼的中枢调度器”,纯C语言，提供了非常多强大的函数
- <2>.GCD的优势
- GCD是苹果公司为多核的并行运算提出的解决方案
- GCD会自动利用更多的CPU内核（比如双核、四核）
- GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
- 程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
- <3>.GCD中有2个核心概念:任务和队列
- 任务：执行什么操作
- 队列：用来存放任务
- <4>.GCD的使用就2个步骤
- 1.定制任务,确定想做的事情
- 2.将任务添加到队列中
- GCD会自动将队列中的任务取出，放到对应的线程中执行
- 任务的取出遵循队列的FIFO原则：先进先出，后进后出
- <5>.执行任务
- GCD中有2个用来执行任务的函数
1.用同步的方式执行任务(不具备开辟新线程的能力)
dispatch_sync(dispatch_queue_t queue,dispatch_block_t block);
queue：队列
block：任务
2.用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
同步和异步的区别:
同步：只能在当前线程中执行任务，不具备开启新线程的能力
异步：可以在新的线程中执行任务，具备开启新线程的能力
- <6>.GCD的队列可以分为
2大类型1.并发队列（Concurrent Dispatch Queue）
- (1).可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
- (2).并发功能只有在异步（dispatch_async）函数下才有效
- 2.串行队列（
Serial Dispatch Queue）
- 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
- <7>.有4个术语比较容易混淆：同步、异步、并发、串行
- 1.同步和异步主要影响：能不能开启新的线程
同步：在当前线程中执行任务，不具备开启新线程的能力
异步：在新的线程中执行任务，具备开启新线程的能力 - 2.并发和串行主要影响：任务的执行方式
并发：多个任务并发（同时）执行
串行：一个任务执行完毕后，再执行下一个任务
- <8>.并发队列
- GCD默认已经提供了全局的并发队列，供整个应用使用，不需要手动创建
- 使用dispatch_get_global_queue函数获得全局的并发队列
dispatch_queue_priority_t priority // 队列的优先级 ,苹果推荐使用DISPATCH_QUEUE_PRIORITY_DEFAULT
unsigned long flags //此参数暂时无用，用0即可
dispatch_queue_t dispatch_get_global_queue( dispatch_queue_priority_t priority, unsigned long flags);
- 获得全局并发队列
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
- 全局并发队列的优先级
#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 // 后
- <9>.全局并发队列与全局串行队列获取方式
- 并发队列:创建的2种方式
获得全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 获取不是全局的并发队列 dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", DISPATCH_QUEUE_CONCURRENT);
- 串行队列:创建的2种方式
获得全局串行队列
dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", DISPATCH_QUEUE_SERIAL); dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", NULL); dispatch_release(queue);非ARC需要释放手动创建的队列
- <10>.主队列
- 主队列（跟主线程相关联的队列）
- 主队列是GCD自带的一种特殊的串行队列
- 放在主队列中的任务，都会放到主线程中执行
- 使用
dispatch_get_main_queue()获得主队列
dispatch_queue_t queue = dispatch_get_main_queue();
- <11>.各种队列的执行效果
注意:使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列
下面写一个GCD线程阻塞的代码
<12>.GCD主线程与子线程之间的通信
从子线程回到主线程
- <13>.GCD里面还有一个来执行任务的函数:
barrier是栅栏
barrier是栅栏的意思,在它前面的任务执行完之后才执行,而且后面的任务等它执行结束后才去执行.
- 注意 这个队列
queue不能是全局的并发队列
dispatch_queue_t queue = dispatch_queue_create("12235", DISPATCH_QUEUE_CONCURRENT); dispatch_barrier_async(queue, ^{ NSLog(@"您在执行barrier"); });
例如下面的代码:
-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event { dispatch_queue_t queue = dispatch_queue_create("12235", DISPATCH_QUEUE_CONCURRENT); dispatch_async(queue, ^{ NSLog(@"1111"); }); dispatch_async(queue, ^{ NSLog(@"2222"); }); dispatch_barrier_async(queue, ^{ NSLog(@"您在执行barrier"); }); dispatch_async(queue, ^{ NSLog(@"3333"); }); dispatch_async(queue, ^{ NSLog(@"4444"); }); }
打印结果如下
八.iOS常见的延时执行有2种方式
- <1>.调用
NSObject的方法
2秒后再调用self的run方法 [self performSelector:@selector(run) withObject:nil afterDelay:2];
- <2>.使用GCD函数
2s后的代码在哪里执行是和队列有关系的
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ NSLog(@"2s了"); });
- <3>.NSTimer定时器
NO代表不重复,定时器执行完就进行销毁,如果是YES就代表每隔2s调用一次run方法
[NSTimer scheduledTimerWithTimeInterval:2 target:self selector:@selector(run) userInfo:nil repeats:NO];
九.一次性代码
使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次 static dispatch_once_t onceToken; dispatch_once(&onceToken,^{ 只执行1次的代码(这里面默认是线程安全的) });
提醒:一次性代码慎用,它是程序在运行过程中只执行一次
十.剪切利用多线程分析 (剪切是耗时的,要放到子线程里面)
- 1.传统的剪切方式
#pragma mark 传统的剪切文件 -(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event { NSString *form = @"/Users/jinqianxiang/Desktop/Form"; NSString *to = @"/Users/jinqianxiang/Desktop/To"; /** * 创建文件管理对象 */ NSFileManager *filemanger = [NSFileManager defaultManager]; //获取要剪切的文件夹里面的每个对象名字 NSArray *array = [filemanger subpathsAtPath:form]; for (NSString *subpath in array) { //全路径 NSString *formPath = [form stringByAppendingPathComponent:subpath]; NSString *toPath = [to stringByAppendingPathComponent:subpath]; dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ //剪切(全路径剪切) [filemanger moveItemAtPath:formPath toPath:toPath error:nil]; }); } }
- 2.比较快的剪切方式
-(void)apply { NSString *form = @"/Users/jinqianxiang/Desktop/Form"; NSString *to = @"/Users/jinqianxiang/Desktop/To"; /** * 创建文件管理对象 */ NSFileManager *filemanger = [NSFileManager defaultManager]; //获取要剪切的文件夹里面的每个对象名字 NSArray *array = [filemanger subpathsAtPath:form]; dispatch_apply(array.count, dispatch_get_global_queue(0, 0), ^(size_t index) { //NSLog(@"456--%@",[NSThread currentThread]); NSString *sunPath = array[index]; //全路径 NSString *formPath = [form stringByAppendingPathComponent:sunPath]; NSString *toPath = [to stringByAppendingPathComponent:sunPath]; //剪切(全路径剪切) [filemanger moveItemAtPath:formPath toPath:toPath error:nil]; NSLog(@"---%@---%zd",[NSThread currentThread],index); }); }
文件的剪切demo 密码: 7edp
十一.GCD队列组和栅栏(barrier)一样的效果:确定线程的优先级顺序
- 有这么1种需求?
- 首先：分别异步执行2个耗时的操作
- 其次：等2个异步操作都执行完毕后，再回到主线程执行操作
如果想要快速高效地实现上述需求，可以考虑用队列组
dispatch_group_t group = dispatch_group_create(); // 1. dispatch_group_async(group,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0),^{ //执行1个耗时的异步操作 }); //2. dispatch_group_async(group,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0),^{ //执行1个耗时的异步操作 }); //3. dispatch_group_notify(group,dispatch_get_main_queue(),^{ //等前面的异步操作都执行完毕后，回到主线程... });
这样就是1和2执行完了才会执行3
下面以两张图片合成为例:
两张图片合成demo 密码: 3w5f
关键性代码:
/** * 3.将两个图片合成 */ dispatch_group_notify(group, queue, ^{ /** * 开启新的图形上下文 */ UIGraphicsBeginImageContext(CGSizeMake(200, 200)); //绘制图片 [self.image1 drawInRect:CGRectMake(0, 0, 200, 100)]; //绘制图片 [self.image2 drawInRect:CGRectMake(0, 100, 200, 100)]; /** * 取得上下文里面的图片 */ UIImage *image = UIGraphicsGetImageFromCurrentImageContext(); /** * 结束上下文 */ UIGraphicsEndImageContext(); /** * 4.进入主队列加载合成的图片 */ dispatch_async(dispatch_get_main_queue(), ^{ self.imageView.image = image; });
十二.GCD单例模式
- 1.单例模式的作用
- 可以保证在程序运行过程，一个类只有一个实例，而且该实例易于供外界访问
- 从而方便地控制了实例个数，并节约系统资源
- 2.单例模式的使用场合
- 在整个应用程序中，共享一份资源（这份资源只需要创建初始化1次）
- 3.单例模式在ARC\MRC环境下的写法有所不同，需要编写2套不同的代码
- 可以用宏判断是否为ARC环境
#if __has_feature(objc_arc) //ARC #else //MRC #endif
- 4.GCD单例模式1(比较简单)
#import "PersonMessages.h" static PersonMessages *personMessages; @implementation PersonMessages +(instancetype)allocWithZone:(struct _NSZone *)zone { static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ personMessages = [super allocWithZone:zone]; }); return personMessages; } @end
说明:不管是alloc还是allocWithZone 都会调用allocWithZone
- 5.完整的一个单例(粒)对象的.m包含3个部分
下面还是以PersonMessages类为例
.h里面
#import <Foundation/Foundation.h> @interface PersonMessages : NSObject +(instancetype)sharePersonMessages; @end
.m里面
#import "PersonMessages.h" @implementation PersonMessages static PersonMessages *personMessages; /** * 1.保证调用 [ PersonMessages sharePersonMessages] 只会调用一次init * * @return personMessages */ +(instancetype)sharePersonMessages { static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ personMessages = [[self alloc]init]; }); return personMessages; } /** * 2.外面调用n次访问同一个对象 * * @return personMessages */ +(instancetype)allocWithZone:(struct _NSZone *)zone { static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ personMessages = [super allocWithZone:zone]; }); return personMessages; } /** * 3.外面进行copy的时候还是同一个对象 * * @return personMessages; */ -(id)copy { return personMessages; } @end
解释一下:
1.static:意思防止外面人访问更改
static PersonMessages *personMessages;
2.once默认是安全的(已经加锁), onceToken是来记录访问过block
dispatch_once(&onceToken, ^{ personMessages = [super allocWithZone:zone]; });
- 6.对单例(粒)的一种封装,只需要传类名
下面我对单例类进行封装解释
GCD单例的封装 密码: yxan
传统单例的封装 密码: xxne
使用方法:图中3步
.h
.m
十三.NSOperation
- <1>.NSOperation的作用
配合使用NSOperation和NSOperationQueue也能实现多线程编程 - <2>.NSOperation和NSOperationQueue实现多线程的具体步骤
- (1).先将需要执行的操作封装到一个
NSOperation对象中 - (2).然后将
NSOperation对象添加到NSOperationQueue中 - (3).系统会自动将
NSOperationQueue中的NSOperation取出来 - (4).将取出的
NSOperation封装的操作放到一条新线程中执行
注意:
- <3>.NSOperation的子类
NSOperation是个抽象类，并不具备封装操作的能力，必须使用它的子类
- <4>.使用NSOperation子类的方式有3种
- (1).
NSInvocationOperation - (2).
NSBlockOperation - (3).自定义子类继承
NSOperation，实现内部相应的方法
- <5>.NSInvocationOperation
- 创建NSInvocationOperation对象
-(id)initWithTarget:(id)target selector:(SEL)sel object:(id)arg; - 2.调用start方法开始执行操作
-(void)start;
一旦执行操作，就会调用target的sel方法 - 3.注意:
默认情况下，调用了start方法后并不会开一条新线程去执行操作，而是在当前线程同步执行操作
只有将NSOperation放到一个NSOperationQueue中，才会异步执行操作(也就是进入子线程)
- <6>.NSBlockOperation
** 一张图**
NSOperationQueue的作用 - 如果将`NSOperation`添加到`NSOperationQueue`（操作队列）中，系统会**自动异步执行**NSOperation中的操作:相当于`start` 另外还可以直接用队列添加Operation /** * 1.创建队列 */ NSOperationQueue *operationQueue = [NSOperationQueue new]; /** * 特殊情况,队列直接添加operation(添加任务) */ [operationQueue addOperationWithBlock:^{ NSLog(@"%@",[NSThread currentThread]); }];
- <7>.自定义创建NSOperation
、
注意:放到队列之后,它会自动开启start
NSOperation创建的3中形式 密码: qaex
- <8>.最大并发数
- 并发数是指:同时执行的任务数,比如，同时开3个线程执行3个任务，并发数就是3
- 最大并发数也就是
NSOperationQueue的属性maxConcurrentOperationCount,当=1时就是串行队列了
/** * 1.创建队列 */ NSOperationQueue *operationQueue = [NSOperationQueue new]; /** * 2.设置最大并发数 */ operationQueue.maxConcurrentOperationCount = 1;
- 最大并发数只要大于1,是几就代表几条线程同时执行,执行完的线程有可能会被重复利用
最大并发数 密码: xxwk
- <9>.队列的取消、暂停、恢复(操作对象是:队列
NSOperationQueue)
- 取消队列的所有操作
-(void)cancelAllOperations;
提示：也可以调用NSOperation的-(void)cancel方法取消单个操作
提示:在自定义的NSOperation的-(void)main{}方法里面,如果线程取消了,我们应该进行判断,防止性能消耗
- 暂停和恢复队列
@property (getter=isSuspended) BOOL suspended; -(void)setSuspended:(BOOL)b;// YES代表暂停队列，NO代表恢复队列 -(BOOL)isSuspended;
举个例子:
NSOperationQueue的挂起和取消 密码: 58is
- <10>.操作依赖注意:依赖必须添加到NSOperation对象添加到队列之前进行依赖
- NSOperation之间可以设置依赖来保证执行顺序
- 比如一定要让操作A执行完后，才能执行操作B，可以这么写
[operationB addDependency:operationA];// 操作B依赖于操作A
- 可以在不同queue的NSOperation之间创建依赖关系(添加的是NSOperation的对象,不管是不是在同一个队列:也可以说能够跨队列)
<11>.操作的监听
可以监听一个操作的执行完毕
-(void(^)(void))completionBlock; -(void)setCompletionBlock:(void(^)(void))block;
最后:提一下图片的缓存机制
- 内存缓存
- 沙盒缓存
- 硬盘缓存
/** * 1.内存缓存图片 */ @property(nonatomic,strong) NSMutableDictionary *dataDictionary; NSString *stringImage = [NSString stringWithFormat:@"%@",self.plist[indexPath.row]]; //先从内存缓存中取出图片 UIImage *image = self.dataDictionary[stringImage]; if (image) {//内存有图片 cell.imageCellPicture.image = image; }else{// 内存中没有图片 dispatch_async(dispatch_get_global_queue(0, 0), ^{ //获取Library/Caches 文件夹 NSString *cachesPath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) firstObject]; //获取文件名(也就是取得路径的最后一个路径) NSString *fileName = [stringImage lastPathComponent]; //计算出全路径 NSString *filePath = [cachesPath stringByAppendingPathComponent:fileName]; //取出图片 NSData *data = [NSData dataWithContentsOfFile:filePath]; if(data){//直接利用沙盒中图片 dispatch_async(dispatch_get_main_queue(), ^{ cell.imageCellPicture.image = [UIImage imageWithData:data]; }); //存到字典中 self.dataDictionary[stringImage] = cell.imageCellPicture.image; }else { // 下载图片 data = [NSData dataWithContentsOfURL:[NSURL URLWithString:stringImage]]; UIImage *image1 = [UIImage imageWithData:data]; dispatch_async(dispatch_get_main_queue(), ^{ cell.imageCellPicture.image = image1; }); // 存到字典中 self.dataDictionary[stringImage] = cell.imageCellPicture.image; // 将图片文件数据写入沙盒中 [data writeToFile:filePath atomically:YES]; } }); }
图片缓存代码<不完善> 密码: wjhv
完善的图片缓存 密码: gr3k
最后再总结一下队列类型
GCD 的队列类型
- 1.并发队列
- 自己创建的
- 全局
并发队列:创建的2种方式
获得全局并发队列 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 获取不是全局的并发队列 dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", DISPATCH_QUEUE_CONCURRENT);
- 2.串行队列
- 主队列
- 自己创建的
串行队列:创建的2种方式 获得全局串行队列 dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", DISPATCH_QUEUE_SERIAL); dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", NULL); dispatch_release(queue);非ARC需要释放手动创建的队列
NSOperationQueue队列类型
- 主队列
- [NSOperationQueue mainQueue];
- 凡是添加到主队列中的任务NSOperation,都会到主线程中执行
- 非主队列(其他队列)
- [[NSOperationQueue alloc]init];
- 同时包含了:串行,并发功能
- 添加到这种队列中的任务(NSOperation),就会自动放到主线程中执行
