.一.进程
进程:是指在系统中正在运行的一个应用程序,每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内
比如同时打开迅雷、Xcode，系统就会分别启动2个进程
二.线程
1.什么是线程?
答:1个进程要想执行任务，必须得有线程(每1个进程至少要有1条线程),一个进程(程序)的所有任务都在线程中执行
比如使用酷狗播放音乐、使用迅雷下载电影，都需要在线程中执行
2.线程的串行
<1>.1个线程中任务的执行是串行的,如果要在1个线程中执行多个任务，那么只能一个一个地按顺序执行这些任务,也就是说，在同一时间内，1个线程只能执行1个任务
<2>.比如在1个线程中下载3个文件(分别是文件A、文件B、文件C)
3.多线程
<1>什么是多线程?
答:1个进程中可以开启多条线程，每条线程可以并行(同时)执行不同的任务,多线程技术可以提高程序的执行效率.
比如下载文件:可以同时下载
<2>.多线程的原理
多线程的原理
(1).同一时间，CPU只能处理1条线程，只有1条线程在工作(执行)
(2).多线程并发(同时)执行，其实是CPU快速地在多条线程之间调度(切换)
(3).如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象
问题:如果线程非常非常多，会发生什么情况？
答:1.CPU会在N多线程之间调度，CPU会累死，消耗大量的CPU资源,2.每条线程被调度执行的频次会降低(线程的执行效率降低)
<3>.多线程的优缺点
多线程的优点:1.能适当提高程序的执行效率,2.能适当提高资源利用率(CPU、内存利用率)
多线程的缺点:1.创建线程是有开销的，iOS下主要成本包括：内核数据结构(大约1KB)、栈空间(子线程512KB、主线程1MB，也可以使用-setStackSize:设置，但必须是4K的倍数，而且最小是16K)，创建线程大约需要90毫秒的创建时间,2.如果开启大量的线程，会降低程序的性能,3.线程越多，CPU在调度线程上的开销就越大,4.程序设计更加复杂：比如线程之间的通信、多线程的数据共享
三.多线程在iOS开发中的应用
(1).主线程
1.什么是主线程?
答:一个iOS程序运行后，默认会开启1条线程，称为“主线程”或“UI线程”
2.主线程的主要作用
显示\刷新UI界面
处理UI事件(比如点击事件、滚动事件、拖拽事件等)
3.主线程的使用注意
别将比较耗时的操作放到主线程中
耗时操作会卡住主线程，严重影响UI的流畅度，给用户一种“卡”的坏体验
4.如果将耗时操作放在主线程:主线程的的UI无法更新,按钮不可用,必须等耗时操作完成才有反应
耗时操作放在主线程
耗时操作demo 密码: qugm
5.如果将耗时操作放在子线程(后台线程、非主线程)
四.iOS中多线程的实现方案
iOS中多线程的实现方案
五.对多线程开辟的详细介绍
1.pthread的详细介绍
1.导入: #import
2.开辟子线程(调用的是一个函数)
pthread_t thread;
/*
pthread 属于POSIX 多线程开发框架
参数
1：指向线程的指针
2：线程属性
3：指向函数的指针
4：传递给函数的参数
返回值：特别在C语言框架，非常常见
如果是0，表示正确 noErr
如果是非0，表示错误代码
void * (*) (void *)
void * demo (void *param)
返回值 函数指针 参数
void * 等价于 OC id
*/
NSString *str = @"我是参数";
int result = pthread_create(&thread, NULL, &run,(__bridge void *)(@"我是参数"));
if (result == 1) {
// 可以把1 换为 noErr
NSLog(@"OK");
}else{
NSLog(@"error: %d",result);
}
3.调用子线程
void *run(void *param)
{
for (NSInteger i = 0; i<50000; i++)
{
NSLog(@"-----buttonClick-----%zd",i);
}
return NULL;
}
2.NSThread
(1).一个NSThread对象就代表一条线程(这种创建方式可以拿到线程的对象以及可以对线程设置名字,以及获取主线程)子线程执行完任务就自动死亡
创建、启动线程
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
[thread start];
//线程一启动，就会在线程thread中执行self的run方法
(2).主线程相关用法
+(NSThread *)mainThread;// 获得主线程
-(BOOL)isMainThread;// 是否为主线程
+(BOOL)isMainThread; // 是否为主线程
(3).其他用法
<1>获得当前线程
NSThread *current = [NSThread currentThread];
<2>.线程的属性：名字(name)(在项目开发中，可以根据这个来查找崩溃原因)
- (void)setName:(NSString*)n;
-(NSString *)name;
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
thread. name = @"JK";
[thread start];
<3>.线程的属性：优先级(threadPriority)
/*
优先级别：0.0 - 1.0；0.5
0.0：最低
1.0：最高
只是保证CPU的调度的可能性；
多线程目的：将耗时操作放在后台执行
建议：不要在开发过程，修改优先级
*/
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
thread. threadPriority = 1;
[thread start];
(4).其他创建线程方式
<1>.创建线程后自动启动线程
[NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
<2>.隐式创建并启动线程(其实也就是在后台创建子线程)
[self performSelectorInBackground:@selector(run) withObject:nil];
上述2种创建线程方式的优缺点
优点：简单快捷
缺点：无法对线程进行更详细的设置
(5).线程的状态
线程的状态
(6).控制线程状态
<1>.启动线程
-(void)start;
进入就绪状态 -> 运行状态。当线程任务执行完毕，自动进入死亡状态
<2>.阻塞(暂停)线程
+(void)sleepUntilDate:(NSDate *)date;// 进入阻塞状态
+(void)sleepForTimeInterval:(NSTimeInterval)ti;// 进入阻塞状态
<3>.强制停止线程
+(void)exit; //进入死亡状态 例如: [NSThread exit];//线程强制退出
注意：一旦线程停止(死亡)了，就不能再次开启任务,必须开辟新的线程
(7).多线程的安全隐患:资源共享
<1>.1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源
<2>. 比如多个线程访问同一个对象、同一个变量、同一个文件
<3>.当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题
第一个例子: 银行取钱
银行取钱
第二个例子: 售票
售票
安全问题分析
<4>.安全隐患解决– 互斥锁 : 加锁是消耗资源的
安全解决方案
(1).互斥锁使用格式
(2).互斥锁的优缺点
优点：能有效防止因多线程抢夺资源造成的数据安全问题
缺点：需要消耗大量的CPU资源
(3).互斥锁的使用前提：多条线程抢夺同一块资源
(4).相关专业术语：线程同步
线程同步的意思是：多条线程在同一条线上执行(按顺序地执行任务)
互斥锁，就是使用了线程同步技术
(5)、互斥锁的使用范围：尽量要小，范围大，效率就会差。
抢票资源的解决问题
抢票资源的解决问题
六.线程之间的通信
<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:意思是主线程刷新的同时,其他线程也在执行任务
YES与NO的区别
七.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线程阻塞的代码
GCD线程阻塞的代码
<12>.GCD主线程与子线程之间的通信
从子线程回到主线程
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 *)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 *)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);
});
}
比较快的剪切方式
十一.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
下面以两张图片合成为例:
两张图片合成为例
关键性代码:
/**
* 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
@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
1
.m
2
十三.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中，才会异步执行操作(也就是进入子线程)
NSInvocationOperation
<6>.NSBlockOperation
** 一张图**
NSBlockOperation
NSOperationQueue的作用
- 如果将`NSOperation`添加到`NSOperationQueue`(操作队列)中，系统会**自动异步执行**NSOperation中的操作:相当于`start`
另外还可以直接用队列添加Operation
/**
* 1.创建队列
*/
NSOperationQueue *operationQueue = [NSOperationQueue new];
/**
* 特殊情况,队列直接添加operation(添加任务)
*/
[operationQueue addOperationWithBlock:^{
NSLog(@"%@",[NSThread currentThread]);
}];
<7>.自定义创建NSOperation
1.自定义创建NSOperation
2.自定义创建NSOperation
注意:放到队列之后,它会自动开启start
<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;
举个例子:
暂停或者取消队列
<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];
}
});
}
沙盒缓存
完善的图片缓存 密码: 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),就会自动放到主线程中执行
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
