一 多线程基础
什么是进程?
- 进程是指在系统中正在运行的一个应用程序。
- 每个进程之间是独立的,每个进程均运行在其专用且受保护的内存空间内。
什么是线程?
- 1个进程要想执行任务,必须得有线程(每1个进程至少要有1条线程)。
- 1个线程中任务的执行是串行的(执行完上一个才能执行下一个)。
什么是多线程?
- 1个进程中可以开启多条线程,多条线程可以并行(同时)执行不同的任务。
- 线程可以并行, 但是每个线程中的任务还是串行。
多线程原理
- 多线程并发(同时)执行,其实是CPU快速地在多条线程之间调度(切换)。
多线程优缺点
- 优点
- 能适当提高程序的执行效率;
- 能适当提高资源利用率(CPU、内存利用率);
- 缺点
- 线程越多,CPU在调度线程上的开销就越大;
- 如果开启大量的线程,会降低程序的性能;
- 程序设计更加复杂:比如线程之间的通信、多线程的数据共享。
- 优点
二 多线程在ios开发中的应用
什么是主线程?
- 一个iOS程序运行后,默认会开启1条线程,称为“主线程”或“UI线程”。
主线程的主要作用
- 显示\刷新UI界面;
- 处理UI事件(比如点击事件、滚动事件、拖拽事件等);
主线程的使用注意
- 别将比较耗时的操作放到主线程中;
- 耗时操作会卡住主线程,严重影响UI的流畅度,给用户一种“卡”的坏体验;
1.如何获取主线程
/*
// 如果是主线程, 那么名称叫做main/ number = 1
// 如果不是主线程, 那么名称就不叫做main / number != 1
// 注意: currentThread代表拿到当前线程, 如果当前执行的方法是被主线程执行的, 那么拿到的就是主线程, 如果不是被主线程执行的, 那么拿到的就不是主线程
NSLog(@"%@", [NSThread currentThread]);
// 明确告诉系统, 需要拿到主线程
NSLog(@"%@", [NSThread mainThread]);
*/
// 2.如何判断当前方法是否实在主线程中执行的
/*
if ([NSThread isMainThread]) {
NSLog(@"当前方法是在主线程中执行的");
}
三 ios中多线程的实现方法
一. pthread
- 类型: C语言中类型的结尾通常 _t/Ref,而且不需要使用 *
- 创建C语言对象,一般都用creat
/*
参数:
1. 线程代号的地址
2. 线程的属性
3. 调用函数的指针
- void *(*)(void *)
- 返回值 (函数指针)(参数)
- void * 和 OC 中的 id 是等价的
4. 传递给该函数的参数
返回值:
如果是0,表示正确
如果是非0,表示错误码
*/
NSString *str = @"lnj";
pthread_t thid;
int res = pthread_create(&thid, NULL, &demo, (__bridge void *)(str));
if (res == 0) {
NSLog(@"OK");
} else {
NSLog(@"error %d", res);
}
二. NSThread
一个NSThread对象就代表一条线程。
创建线程的几种方式
- alloc/init
// 1.创建线程
NJThread *thread = [[NJThread alloc] initWithTarget:self selector:@selector(demo:) object:@"lnj"];
// 设置线程名称
[thread setName:@"lmg"];
// 设置线程的优先级,取值范围是0.0~1.0,默认是0.5
// 优先级仅仅说明被CPU调用的可能性更大
[thread setThreadPriority:1.0];
// 2.启动线程
[thread start];
- detach/performSelector
- 优点:简单快捷
- 缺点:无法对线程进行更详细的设置
1.创建线程(创建线程后自动启动线程)
[NSThread detachNewThreadSelector:@selector(demo:) toTarget:self withObject:@"lnj"];
// 1.创建线程(隐式创建并启动线程)
// 注意: Swift中不能使用, 苹果认为这个方法不安全
[self performSelectorInBackground:@selector(demo:) withObject:@"lnj"];
三. GCD
四. NSOperation
四 线程的状态
1.启动线程
- (void)start;
// 进入就绪状态 -> 运行状态。当线程任务执行完毕,自动进入死亡状态
2.阻塞(暂停)线程
+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)time;
// 进入阻塞状态
[NSThread sleepForTimeInterval:2.0]; //线程睡2s
[NSThread sleepUntilDate:[NSDate distantFuture]]; //线程一直睡
3.强制停止线程
+ (void)exit;
// 进入死亡状态
[NSThread exit];
注意:一旦线程停止(死亡)了,就不能再次开启任务
五 多线程的安全隐患
资源共享
- 1块资源可能会被多个线程共享,也就是多个线程可能会访问同一块资源
- 比如多个线程访问同一个对象、同一个变量、同一个文件
当多个线程访问同一块资源时,很容易引发数据错乱和数据安全问题
解决方法–互斥锁:
@synchronized(锁对象) { // 需要锁定的代码 }
// 售票方法
- (void)saleTicket
{
while (1) {
NSLog(@"欢迎光临");
// 只要被synchronized{}扩住, 就能实现同一时刻, 只能有一个线程操作
/*
// 注意:
// 1. 如果多条线程访问同一个资源, 那么必须使用同一把锁才能锁住
// 2. 在开发中, 尽量不要加锁, 如果必须要加锁, 一定记住, 锁的范围不能太大, 哪里会有安全隐患就加在哪里
*/
/*
技巧: 开发中如果需要加锁, 一般都使用self
*/
// 线程2: 等待, 线程3: 等待
@synchronized(self){ // 锁住
// 1.查询剩余的票数
NSUInteger count = self.totalCount;
// 2.判断是否还有余票
if (count > 0) {
// 线程1 100
[NSThread sleepForTimeInterval:0.1];
// 2.1卖票
self.totalCount = count - 1; // 99
NSLog(@"%@卖了一张票, 还剩%zd票", [NSThread currentThread].name, self.totalCount);
}else
{
// 3.提示客户, 没有票了
NSLog(@"对不起, 没有票了");
break;
}
} // 解锁
}
}
互斥锁的优缺点
优点:能有效防止因多线程抢夺资源造成的数据安全问题
缺点:需要消耗大量的CPU资源互斥锁注意点
- 锁定1份代码只用1把锁,用多把锁是无效的
- 锁定范围越大, 性能越差
原子和非原子属性
- atomic:线程安全,需要消耗大量的资源
- nonatomic:非线程安全,适合内存小的移动设备
自旋锁 & 互斥锁
Synchronized: 互斥锁 —– Atomic: 自旋锁
- 共同点
都能够保证同一时间,只有一条线程执行锁定范围的代码 - 不同点
- 互斥锁:如果发现有其他线程正在执行锁定的代码,线程会进入”休眠”状态,等待其他线程执行完毕,打开锁之后,线程会被”唤醒”
- 自旋锁:如果发现有其他线程正在执行锁定的代码,线程会”一直等待”锁定代码执行完成!
自旋锁更适合执行非常短的代码,比较适合做一些不耗时的操作!
- 共同点
六 线程间通信
什么叫做线程间通信
- 在1个进程中,线程往往不是孤立存在的,多个线程之间需要经常进行通信
线程间通信的体现
- 1个线程传递数据给另1个线程
- 在1个线程中执行完特定任务后,转到另1个线程继续执行任务
线程间通信常用方法:
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait;
- 子线程做耗时操作, 主线程更新数据
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
// 开启一个子线程下载图片
[self performSelectorInBackground:@selector(downlod) withObject:nil];
}
- (void)downlod
{
NSLog(@"%@", [NSThread currentThread]);
// 1.下载图片
NSURL *url = [NSURL URLWithString:@"http://pic.4j4j.cn/upload/pic/20130531/07ed5ea485.jpg"];
NSData *data = [NSData dataWithContentsOfURL:url];
// 2.将二进制转换为图片
UIImage *image = [UIImage imageWithData:data];
// 3.跟新UI
/*
waitUntilDone是否等待被调用方法执行完成,有可能也会等待调用方法的执行完成!
YES: 等待被调用线程执行完毕再执行后面的代码
NO : 不用等待被调用线程执行完毕就可以执行后面的代码
*/
// 可以在指定的线程中, 调用指定对象的指定方法
[self performSelectorOnMainThread:@selector(showImage:) withObject:[UIImage imageWithData:data] waitUntilDone:YES];
}
七 多线程GCD
- 什么是GCD
- 全称是Grand Central Dispatch,可译为“牛逼的中枢调度器”
GCD的优势
- GCD是苹果公司为多核的并行运算提出的解决方案
- GCD会自动利用更多的CPU内核(比如双核、四核)
- GCD会自动管理线程的生命周期(创建线程、调度任务、销毁线程)
- 程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码
GCD中有2个核心概念
- 任务:执行什么操作
- 队列:用来存放任务
GCD的使用就2个步骤:
1、定制任务
* 确定想做的事情
2、将任务添加到队列中
* GCD会自动将队列中的任务取出,放到对应的线程中执行
* 任务的取出遵循队列的FIFO原则:先进先出,后进后出执行任务
GCD中有2个用来执行任务的常用函数:
//用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
queue:队列
block:任务
//用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
- 同步和异步的区别
* 同步:只能在当前线程中执行任务,不具备开启新线程的能力
* 异步:可以在新的线程中执行任务,具备开启新线程的能力
队列的类型
- 并发队列
- 可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)
- 并发功能只有在异步(dispatch_async)函数下才有效
- 串行队列
- 让任务一个接着一个地执行(一个任务执行完毕后,再执行下一个任务)
- 并发队列
注意点
- 同步和异步主要影响:能不能开启新的线程
- 同步:只是在当前线程中执行任务,不具备开启新线程的能力
- 异步:可以在新的线程中执行任务,具备开启新线程的能力
- 并发和串行主要影响:任务的执行方式
- 并发:允许多个任务并发(同时)执行
- 串行:一个任务执行完毕后,再执行下一个任务
- 同步和异步主要影响:能不能开启新的线程
并发队列
1.使用dispatch_queue_create函数创建队列
dispatch_queue_t
dispatch_queue_create(const char *label, // 队列名称
dispatch_queue_attr_t attr); // 队列的类型
// 创建并发队列
dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", DISPATCH_QUEUE_CONCURRENT);
2.系统提供的全局的并发队列
// 使用dispatch_get_global_queue函数获得全局的并发队列
dispatch_queue_t dispatch_get_global_queue(
dispatch_queue_priority_t priority, // 队列的优先级
unsigned long flags); // 此参数暂时无用,用0即可
// 获得全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
- 串行队列
- GCD中获得串行有2种途径
1.使用dispatch_queue_create函数创建串行队列
- GCD中获得串行有2种途径
// 创建串行队列(队列类型传递NULL或者DISPATCH_QUEUE_SERIAL)
dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", NULL);
2.使用主队列(跟主线程相关联的队列)
主队列是GCD自带的一种特殊的串行队列
放在主队列中的任务,都会放到主线程中执行
使用dispatch_get_main_queue()获得主队列
dispatch_queue_t queue = dispatch_get_main_queue();
- 各种任务队列搭配
- 异步 + 并发 : 会开启新的线程
/*
第一个参数: 队列的名称
第二个参数: 告诉系统需要创建一个并发队列还是串行队列
DISPATCH_QUEUE_SERIAL :串行
DISPATCH_QUEUE_CONCURRENT 并发
*/
dispatch_queue_t queue = dispatch_queue_create("com.520it", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
NSLog(@"任务1 == %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务2 == %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务3 == %@", [NSThread currentThread]);
});
系统内部提供一个现成的并发队列
/*
第一个参数: iOS8以前是优先级, iOS8以后是服务质量
iOS8以前
* - DISPATCH_QUEUE_PRIORITY_HIGH 高优先级 2
* - DISPATCH_QUEUE_PRIORITY_DEFAULT: 默认的优先级 0
* - DISPATCH_QUEUE_PRIORITY_LOW: 低优先级 -2
* - DISPATCH_QUEUE_PRIORITY_BACKGROUND:
iOS8以后
* - QOS_CLASS_USER_INTERACTIVE 0x21 用户交互(用户迫切想执行任务)
* - QOS_CLASS_USER_INITIATED 0x19 用户需要
* - QOS_CLASS_DEFAULT 0x15 默认
* - QOS_CLASS_UTILITY 0x11 工具(低优先级, 苹果推荐将耗时操作放到这种类型的队列中)
* - QOS_CLASS_BACKGROUND 0x09 后台
* - QOS_CLASS_UNSPECIFIED 0x00 没有设置
第二个参数: 废物
*/
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
- 异步 + 串行:会开启新的线程,但是只会开启一个新的线程
// 1.创建串行队列
dispatch_queue_t queue = dispatch_queue_create("com.520it", DISPATCH_QUEUE_SERIAL);
/*
能够创建新线程的原因:使用"异步"函数调用
只创建1个子线程的原因:队列是串行队列
*/
// 2.将任务添加到队列中
dispatch_async(queue, ^{
NSLog(@"任务1 == %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务2 == %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务3 == %@", [NSThread currentThread]);
});
- 同步 + 串行:如果是调用同步函数, 那么会等同步函数中的任务执行完毕, 才会执行后面的代码
dispatch_queue_t queue = dispatch_queue_create("com.520it", NULL);
// 2.将任务添加到队列中
dispatch_sync(queue, ^{
NSLog(@"任务1 == %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"任务2 == %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"任务3 == %@", [NSThread currentThread]);
});
- 同步 + 并发 : 不会开启新的线程
// 1.创建一个并发队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
// 2.将任务添加到队列中
dispatch_sync(queue, ^{
NSLog(@"任务1 == %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"任务2 == %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"任务3 == %@", [NSThread currentThread]);
});
- 异步 + 主队列 : 不会创建新的线程, 并且任务是在主线程中执行
// 主队列特点: 只要将任务添加到主队列中, 那么任务"一定"会在主线程中执行 \
无论你是调用同步函数还是异步函数:
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
NSLog(@"%@", [NSThread currentThread]);
});
- 同步函数 + 主队列
- 如果是在主线程中调用同步函数 + 主队列, 那么会导致死锁
导致死锁的原因:
如果是调用同步函数, 那么会等同步函数中的任务执行完毕, 才会执行后面的代码;
sync函数是在主线程中执行的, 并且会等待block执行完毕. 先调用
block是添加到主队列的, 也需要在主线程中执行. 后调用 - 在子线程中调用 同步函数 + 主队列
- 如果是在主线程中调用同步函数 + 主队列, 那么会导致死锁
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_async(queue, ^{
// block会在子线程中执行
// NSLog(@"%@", [NSThread currentThread]);
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
// block一定会在主线程执行
NSLog(@"%@", [NSThread currentThread]);
});
});
八 GCD线程间通信
// 1.除主队列以外, 随便搞一个队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
// 2.调用异步函数
dispatch_async(queue, ^{
// 1.下载图片
NSURL *url = [NSURL URLWithString:@"http://pic.4j4j.cn/upload/pic/20130531/07ed5ea485.jpg"];
NSData *data = [NSData dataWithContentsOfURL:url];
// 2.将二进制转换为图片
UIImage *image = [UIImage imageWithData:data];
// 3.回到主线程更新UI
// self.imageView.image = image;
/*
技巧:
如果想等UI更新完毕再执行后面的代码, 那么使用同步函数
如果不想等UI更新完毕就需要执行后面的代码, 那么使用异步函数
*/
dispatch_sync(dispatch_get_main_queue(), ^{
self.imageView.image = image;
});
NSLog(@"设置图片完毕 %@", image);
});
九 GCD其它常用方法
- 延时执行
方法一:调用NSObject的方法
[self performSelector:@selector(run) withObject:nil afterDelay:2.0];
// 2秒后再调用self的run方法
方法二:使用GCD函数
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2秒后执行这里的代码...
});
- 一次性代码
使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});
- 快速迭代
使用dispatch_apply函数能进行快速迭代遍历
dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index){
// 执行10次代码,index顺序不确定
});
应用场景–拷贝文件:
// 1.定义变量记录原始文件夹和目标文件夹的路径
NSString *sourcePath = @"/Users/xiaomage/Desktop/test";
NSString *destPath = @"/Users/xiaomage/Desktop/lnj";
// 2.取出原始文件夹中所有的文件
NSFileManager *manager = [NSFileManager defaultManager];
NSArray *files = [manager subpathsAtPath:sourcePath];
// NSLog(@"%@", files);
// 3.开始拷贝文件
dispatch_apply(files.count, dispatch_get_global_queue(0, 0), ^(size_t index) {
NSString *fileName = files[index];
// 3.1生产原始文件的绝对路径
NSString *sourceFilePath = [sourcePath stringByAppendingPathComponent:fileName];
// 3.2生产目标文件的绝对路径
NSString *destFilePath = [destPath stringByAppendingPathComponent:fileName];
// NSLog(@"%@", sourceFilePath);
// NSLog(@"%@", destFilePath);
// 3.3利用NSFileManager拷贝文件
[manager moveItemAtPath:sourceFilePath toPath:destFilePath error:nil];
});
- 控制任务之间的关系
- 有这么1种需求
- 首先:分别异步执行2个耗时的操作
- 其次:等2个异步操作都执行完毕后,再回到主线程执行操作
- 有这么1种需求
如果想要快速高效地实现上述需求,可以考虑用队列组
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步操作都执行完毕后,回到主线程...
});