运行速度
操作内存栈空间 > 操作内存堆空间 > I/O操作
同步和异步
同步:从上往下,依次执行,一次执行一个任务
异步:多人同时执行多个任务
进程和线程
进程:系统中的应用程序
线程:一个进程有多个线程(至少一个线程),线程是进程的基本执行单元,一个进程所有任务都在线程中执行
多线程的优缺点
优点
多线程可以解决程序阻塞问题,提高程序执行效率和资源利用率(cpu
,内存),线程上的任务执行完成后,线程自动销毁
缺点
- 开启线程需要占用一定的内存空间(默认
512KB
) - 开启大量线程会占用大量内存空间,降低程序性能
- 线程越多,
cpu
在调用线程的开销越大
主线程(UI线程)
- 主线程一般用来刷新
UI界面
,处理UI事件
(比如:点击、滚动、拖拽等事件) - 几乎所有
UIKit
提供的类都是线程不安全的,所有更新UI
的操作都在主线程上执行 - 所有包含
Mutable
的类都是线程不安全的
别把耗时操作放进主线程
线程的状态
NSThread为例
阻塞状态
[NSThread sleepForTimeInterval:3];
线程退出 死亡状态 线程死亡/结束后不能再次使用,对象销毁了
[NSThread exit];
线程的属性
NSThread为例,有名字之后报错容易找到
thread1.name = @"thread1";
线程的优先级(0.0-1.0 默认0.5) 仅仅是分配的时间片更多
thread1.threadPriority = 1.0;
多线程操作共享资源
任意对象内部都有一把锁,默认开的
synchronized 同步
互斥锁 -> 线程同步
@synchronized(self){
//锁的代码
}
property的atomic原子属性,自带自旋锁 保证同一时间多个线程能取值,但是只有一个能写入,单写多读
尽量将加锁、资源抢夺的业务逻辑交给服务端处理,减少客户端的压力
互斥锁和自旋锁
- 互斥锁:如果发现其他线程正在执行锁定代码,线程会进入体眠(就绪状态),等其它线程时间片到打开锁后,线程会被唤醒(执行)
- 自旋锁:如果发现有其它线程正在锁定代码线程会用死循环的方式,一直等待锁定的代码执行完成,自旋锁更适合执行不耗时的代码
消息循环
-
Runloop
就是消息循环,每一个线程内部都有一个消息循环 - 只有主线程的消息循环默认开启,子线程的消息循环默认不开启
消息循环的目的
- 保证程序不退出
- 负责处理输入事件
- 如果没有事件发生,会让程序进入休眠状态
线程池的实现原理,开启线程后永不销毁,当需要让子线程执行新的方法,使用 performSelector让指定的方法在指定的子线程上运行
子线程的消息循环
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(demo:) object:@"参数"];
[thread start];
往子线程的消息循环添加输入源
[self performSelector:@selector(demo1) onThread:thread withObject:nil waitUntilDone:NO];
-(void)demo:(NSString *)name{
NSLog(@"Hello!";
开始子线程的消息循环,如果开启,消息循环会一直运行
如果消息循环没有添加事件,消息循环会立即结束
//[[NSRunLoop currentRunLoop] run];
消息循环定时结束2s
[[NSRunLoop currentRunLoop] runUnitlDate:[NSDate dateWithTimeIntervalSinceNow:2]];
NSLog(@"end!";
}
-(void)demo1:(NSString *)name{
NSLog(@"Hello!i am in runloop!";
}
IOS的多线程技术方案:pthread、NSThread、GCD、NSOperation
pthread 几乎不用(看看就好)
pthread_create(pthread_t *restrict,const pthread_attr_t *restrict,void *(*)(void *),void *restrict);
pthread_t *restrict 线程编号地址
const pthread_attr_t *restrict 线程属性 NULL
void *(*)(void *) 线程要执行的函数
void *restrict 要执行的函数的参数
函数的返回值int 0是成功 非0是失败(代表错误的原因)
#import <pthread/pthread.h>
pthread_t prthread;//线程编号
char *name = "test";
int result = pthread_create(&pthread,NULL,demo,name);
if(result==0){
NSLog(@"成功");
}else{
NSLog(@"失败");
}
void *demo(void *param){
NSLog(@"hello @s",param);
return NULL;
}
传入的参数是NSString的解决方法
//__bridge 桥接 桥接给ARC管理
//把OC中的对象、传递给C语言的函数,需要桥接
NSString *name = @"test";
pthread_create(&pthread,NULL,demo,(__bridge void*)(name)));
void *demo(void *param){
//需要桥接回来
NSString *name = (__bridge NSString *)(param);
NSLog(@"hello @s",name);
return NULL;
}
NSThread(常用来定位线程)
返回当前线程id
[NSThread currentThread];
判断当前线程是否为主线程
[NSThread isMainThread];
线程暂停
[NSThread sleepForTimeInterval:0.1];
第一种方法
NSThread *thread = [[NSThread alloc] initWithTarget:(nonull id) selector:(nonnull SEL) object:(nullable id)];
参数1:对象 参数2:方法 参数3:参数
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(demo:) object:@"参数"];
需要开始线程
[thread start];
-(void)demo:(NSString *)name{
NSLog(@"Hello! %@",name);
}
第二种方法
直接执行
[NSThread detachNewThreadSelector:@selector(demo) toTarget:self withObject:nil]
第三种方法
[self performSelectorInBackground:@selector(demo) withObject:nil];
回到主线程(线程间通讯)
//主线程更新UI控件 线程间通讯
//waitUntilDone:YES 会等待方法执行完毕
[self performSelectorOnMainThread:@selector(updateUI:) withObject:img waitUntilDone:YES];
异步下载网络图片(NSThread)
//初始化并适应屏幕大小
self.scrollView = [[UIScrollView alloc] initWithFrame:[UIScreen mainScreen].bounds];
self.imageView = [[UIImageView alloc] init];
[self.scrollView addSubview:self.imageView];
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(downloadImage) object:nil];
-(void)downloadImage{
NSURL *url = [NSURL URLWithString:@"图片URL"];
NSDate *data = [NSData dataWithContentsOfURL:url];
//二进制数据转化为图片
UIImage *img = [UIImage imageWithData:data];
//主线程更新UI控件 线程间通讯
//waitUntilDone:YES 会等待方法执行完毕
[self performSelectorOnMainThread:@selector(updateUI:) withObject:img waitUntilDone:YES];
}
-(void)updateUI:(UIImage *)img{
self.imageView.image = img;
//大小和图片保持一致
[self.imageView.frame sizeToFit];
self.scrollView.contentSize = img.size;
}
GCD
GCD全称是 Grand Central Dispatch
,纯C语言
,提供了非常多强大的函数GCD
的优势·
-
GCD
是苹果公司为多核的并行运算提出的解决方案 -
GCD
会自动利用更多的CPU
内核(比如双核、四核) -
GCD
会自动管理线程的生命周期(创建线程、调度任务、销毁线程) 程序员只需要告诉GCD
想要执行什么任务,不需要编写任何线程管理代码
GCD的两个核心:任务和队列
- 创建任务
- 添加到队列:
GCD
会自动将队列中的任务取出,放到对应的线程中执行任务的取出遵循队列的FFO
原则:先进先出,后进后出
方法一
//1创建队列(全局队列)
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
//2创建任务
dispatch_block_t task = ^{
NSLog(@hello,%@", [NSThread currentThread]);
};
//3异步执行
dispatch_async(queue, task);
方法二 简化方法
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@hello,%@", [NSThread currentThread]);
});
回到主线程(同步执行)
dispatch_async(dispatch_get_main_queue(), task);
GCD的队列可以分为两大类型
- 并发队列(
Concurrent Dispatch Queue
)可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务) - 并发功能只有在异步(
dispatch_async
)函数下才有效 - 串行队列(
Serial Dispatch Queue
):让任务一个接着一个地执行(一个任务执行完毕后,再执行下一个任务)
//串行队列,同步执行 不开新线程,任务按照顺序执行
disapatch_queue_t queue = dispatch_queue_create("名字",DISPATH_QUEUE_SERIAL);
dispatch_sync(queue,^{
NSLog(@“Hello!”)
});
//串行队列,异步执行 开新线程,任务按照顺序执行
disapatch_queue_t queue = dispatch_queue_create("名字",DISPATH_QUEUE_SERIAL);
dispatch_async(queue,^{
NSLog(@“Hello!”)
});
//并行队列,同步执行跟串行队列,同步执行一致,不开线程,并行无法实现,实际应用没用
disapatch_queue_t queue = dispatch_queue_create("名字",DISPATH_QUEUE_CONCURRENT);
dispatch_sync(queue,^{
NSLog(@“Hello!”)
});
//并行队列,异步执行 开多个线程无序执行
disapatch_queue_t queue = dispatch_queue_create("名字",DISPATH_QUEUE_CONCURRENT);
dispatch_async(queue,^{
NSLog(@“Hello!”)
});
主队列,异步执行
- 不开线程,同步执行
- 主队列特点:如果主线程正在执行代码暂时不调度任务,等主线程执行结束后在执行任务
- 主队列又叫全局串行队列,主线程
//主队列,异步执行 主线程,顺序执行
dispatch_async(dispatch_get_main_queue(),^{
NSLog(@“Hello!”)
});
主队列,同步执行
- 程序执行不出来(死锁)
- 死锁的原因,当程序执行到下面这段代码的时候
- 主队列:如果主线程正在执行代码,就不调度任务
- 同步执行:如果第一个任务没有执行,就继续等待第一个任务执行成,再执行下一个任务此时互相等待,程序无法往下执行(死锁)
//主队列,同步执行 死锁
dispatch_async(dispatch_get_main_queue(),^{
NSLog(@“Hello!”)
});
//解决方案:开子线程
全局队列
- 全局队列本质就是并发队列
//第一个参数是优先级,即服务质量,默认0
dispatch_get_global_queue(0, 0);
- 全局队列和发队列的区别
- 并发队列有名称,可以跟踪错误,全局队列没有
- 在
ARC
中不需要考虑释放内存,dispatch_release(q);
不允许调用 - 在
MRC
中需要手动释放内存,并发队列是create
创建出来的在MRC
中见到create
就要release
,全局队列不需要release
(只有一个) - 一般我们使用全局队列
dispatch_get_main_queue(); //主队列
dispatch_get_global_queue(0,0);//全局并行队列
dispatch_queue_create("名字",DISPATH_QUEUE_CONCURRENT);//并行队列
dispatch_queue_create("名字",DISPATH_QUEUE_SERIAL);//串行队列
Barrier阻塞
主要用于在多个异步操僬完成之后,统一对非线程安全的对象进行更新
- 适合于大规模的
IO
操作 - 当访问数据库或文件的时候,更新数据的时候不能和其他更新或读取的操作在同一时间执行,可以使用调度组不过有点复杂。也可以使用
dispatch_barrier_async
解决 -
Barrier
栅栏函数只能控制同一并发队列,并且拦不住全局并行队列
dispatch_barrier_async(dispatch_get_global_queue(0,0),^{
//这里说全局队列,其实是拦不住的
//如果是正常的并行队列,等待队列中前面添加的任务执行完成,才会执行barrier代码
});
调度组
执行完调度组再执行后面的内容
//全局队列
dispatch_queue_t queue = dispatch_get_global_queue(0,0);
//调度组
dispatch_group_t group = dispatch_group_create();
//ARC不用写
//dispatch_retain(group);
dispatch_group_async(group,queue,^{
NSLog(@"1");
})
dispatch_group_async(group,queue,^{
NSLog(@"2");
})
//等待调度组,等队列任务全部执行完,执行后续代码,会阻塞进程(很少使用)
dispatch_group_wait(group,DISPATCH_TIME_FOREVER);
//所有任务执行完,获得通知
dispatch_group_notify(group,dispatch_get_main_queue(),^{
NSLog(@"ok");
});
GCD的其他操作
延迟执行
dispatch_after(dispatch_time(DISPATCH_TIME_NOW,(int64_T)(2*NSEC_PER_SEC)),dispatch_get_main_queue(),)^{
//代码区
};
参数1:延迟多少时间 精确到纳秒 参数2:队列 参数3:任务
一次性执行
在当前线程上执行,判断静态的全局变量默认为0,执行完为-1
dispatch_once本身就是线程安全的
static disapatch_once_t onceToken;
dispatch_once(@onceToken,^{
//代码区
});
单例模式中的可用线程锁或者dispatch_once
来判断,dispatch_once
为佳,无需等待
+(instancetype)test{
static id instance =nil;
static disapatch_once_t onceToken;
//下面这个GCD只会在onceToken为空时,执行
dispatch_once(@onceToken,^{
if(instance==nil){
instance=[[self alloc]init];
}
});
}
NSOperation
NSOperation的作用
- 是OC语言中基于GCD的面向对象的封装
- 使用起来比GCD更加简单(面向时象)
- 提供了一些用GCD不好实现的功能
- 苹果推荐使用,使用 Nsoperation不用关心线程以及线程的生命周期
NSOperation的头文件
- NSOperation是一个抽象类:不能直接使用(方法没有实现),约束子类具有共同的属性和方法
- NSOperation的子类:NSInvocationOperation,NSBlockOperation,自定义operation
- NSOperationQueue队列
NSOperation和NSOperationQueue实现多线程的具体步骤
- 1.先将需要执行的操作封装到一个 NSOperation对象中
- 2.然后将 NSOperation对象添加到 NSOperationQueue中 系统会自动将
- NSOperationQueue中的NSOperation取出来
- 将取出的NSOperation封装的操作放到一条新线程中执行,异步执行
NSInvocationOperation
- 建NSInvocationOperation对象
(id)initwithTarget: (id)target selector: (SEL)sel object: (id)arg;
- 调用 start方法开始执行操作
(void)start;
//一旦执行操作,就会调用target的sel方法
注意默认情况下,调用了start方法后并不会开一条新线程去执行操作,而是在当前线程同步执行操作只有将NSOperation放到一个 NSOperationQueue中,才会异步执行操作。
NSInvocationOperation *op =[[NSInvocationOperation alloc]initWithTarget:self selector: @selector(demo) object:nil];
//不会开启新线程
[op start];
//创建操作
NSInvocationOperation *op =[[NSInvocationOperation alloc]initWithTarget:self selector: @selector(demo) object:nil];
//队列
NSOperationQueue queue = [[NSOperationQueue alloc] init];
//把操作添加进队列
[queue addOperation:op];
NSBlockOperation
创建NSBlockOperation对象
+(id)blockOperationWithBlock: (void(^)(void))block;
通过 addexecution Block:方法添加更多的操作
-(void)addExecutionBlock: (void(^)(void))block;
**注意:**只要NSBlockOperation封装的操作数>1,就会异步执行操作
NSBlockOperation *op =[NSBlockOperation blockOperationwithBlock:^{
NSLog("%@",[NSThread currentThread]);
}];
//更新op的状态,执行main方法
[op start];//不会开新线程
//队列
NSOperationQueue queue = [[NSOperationQueue alloc] init];
//操作
NSBlockOperation *op =[NSBlockOperation blockOperationwithBlock:^{
NSLog("%@",[NSThread currentThread]);
}];
//添加进队列
[queue addOperation:op];
可以化简,调用这个方法
NSOperationQueue queue = [[NSOperationQueue alloc] init];
[queue addOperationWithBlock:^{
NSLog("%@",[NSThread currentThread]);
}];
操作的completionBlock
NSBlockOperation *op =[NSBlockOperation blockOperationwithBlock:^{
NSLog("%@",[NSThread currentThread]);
}];
//会在操作完成之后开启一个新线程
[op setCompletionBlock:^{
NSLog("%@",[NSThread currentThread]);
}];
[self.queue addOperation:op];
线程间通讯,回到主线程
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
//在主线程执行的代码
}]
//获取当前队列[NSOperationQueue currentQueue];
NSOperation VS GCD
GCD
-
GCD
是iOS4.0
推出的,主要针对多核cpu
做了优化,是C语言
的技术 -
GCD
是将任务(block
)添加到队列(串行/并行/全局/主队列),并且以同步/异步的方式执行任务的函数 -
GCD
提供了一些NSOperation
不具备的功能:一次性执行,延迟执行,调度组
NSOperation
-
NSOperation
是iOS2.0
推出的,iOS4
之后重写了NSOperation
-
NSOperation
将操作(异步的任务)添加到队列(并发队列),就会执行指定操作的函数 -
NSOperation
里提供的方便的操作:最大并发数,队列的暂定/继续,取消所有的操作,指定操作之间的依赖关系(GCD
可以用同步实现)
NSOperation的最大并发数
同时执行的任务数,比如:同时开3个线程执行3个任务,并发数就3,但是不代表线程数是3
最大并发数的相关方法
-(NSInteger)maxConcurrentOperationCount;
-(void)setMaxConcurrentOperationCount:(NSInteger)cnt;
queue.maxConcurrentOperationCount = 2;
执行的过程
1、把操作添加到队列 self.queue.addoperationwithblock
2、去线程池去取空闲的线程,如果没有就创建线程
3、把操作交给从线程池中取出的线程执行
4、执行完成后,把线程再放回线程池中
5、重复2,3,4知道所有的操作都执行完
NSOperation队列的暂停、取消、恢复
取消队列的所有操作
当前正在执行会继续执行,后续操作会取消
(void)cancelAlloperations;
提示:也可以调用NSOperation的-(void)cancel方法取消单个操作
暂停和恢复队列
当前正在执行会继续执行,后续操作会暂停
-(void)setSuspended:(B00L)b;//YES代表暂停队列,NO代表恢复队列
-(BOOL)isSuspended;
queue.suspended =YES;
queue.operationCount是队列的操作数
NSOperation操作的优先级
设置 Nsoperation在 queue中的优先级,可以改变操作的执行优先级
-(NSOperationQueuePriority)queuePriority;
-(void)setQueuePriority:(NSOperationQueuePriority)p;
//服务质量设置 最高
op.qualityOfService = NSQualityOfServiceUserInteractive;
iOS8以后推荐使用服务质量 qualityOfService 服务质量本质就是优先级
NSOperation操作的依赖
Nsoperation之间可以设置依赖来保证执行顺序
依赖关系可以跨队列
比如一定要让操作A执行完后,才能执行操作B,可以这么写
[operationgB adddependency: operationA];
//操作B依赖于操作A
可以在不同queue的NSOperation之间创建依赖关系
模拟软件升级过程:下载一解压一升级完成
//队列
NSOperationQueue queue = [[NSOperationQueue alloc] init];
//操作
NSBlockOperation *op1 =[NSBlockOperation blockOperationwithBlock:^{
NSLog(@"1");
}];
NSBlockOperation *op2 =[NSBlockOperation blockOperationwithBlock:^{
NSLog(@"2");
}];
NSBlockOperation *op3 =[NSBlockOperation blockOperationwithBlock:^{
NSLog(@"3");
}];
//避免循环依赖,否则不会执行
[op2 adddependency:op1];
[op3 adddependency:op2];
//添加进队列 批量添加
[queue addOperation:@[op1,op2,op3] waitUntilFinished:NO];