多线程
进程与线程
- 进程
- 进程是指在系统中正在运行的一个应用程序,每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内
- 线程
- 1个进程要想执行任务，必须得有线程（每1个进程至少要有1条线程）,一个进程（程序）的所有任务都在线程中执行
-
线程的串行
多线程概念
-
1个进程中可以开启多条线程，多条线程可以并行（同时）执行不同的任务,进程 车间，线程车间工人,多线程技术可以提高程序的执行效率,比如同时开启3条线程分别下载3个文件（分别是文件A、文件B、文件C）
多线程的原理
- 同一时间，CPU只能处理1条线程，只有1条线程在工作（执行）
多线程并发（同时）执行，其实是CPU快速地在多条线程之间调度（切换）,如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象 -
如果线程非常非常多,CPU会在N多线程之间调度，CPU会累死，消耗大量的CPU资源,每条线程被调度执行的频次会降低（线程的执行效率降低）
多线程的优缺点
-
多线程的优点
能适当提高程序的执行效率
能适当提高资源利用率（CPU、内存利用率） -
多线程的缺点
创建线程是有开销的，iOS下主要成本包括：内核数据结构（大约1KB）、栈空间（子线程512KB、主线程1MB，也可以使用-setStackSize:设置，但必须是4K的倍数，而且最小是16K），创建线程大约需要90毫秒的创建时间,如果开启大量的线程，会降低程序的性能,线程越多，CPU在调度线程上的开销就越大,程序设计更加复杂：比如线程之间的通信、多线程的数据共享
iOS中多线程的实现方案
- 主线程
- 1）一个iOS程序运行后，默认会开启1条线程，称为“主线程”或“UI线程”。
- 2）作用。刷新显示UI,处理UI事件。
- 使用注意
- 1）不要将耗时操作放到主线程中去处理，会卡住线程。
- 2）和UI相关的刷新操作必须放到主线程中进行处理
pthread
+ 创建pthread
* pthread_create
+ 只要create一次就会创建一个新的线程
+ 系统会自动在子线程中调用传入的函数
第一个参数: 线程的代号(当做就是线程)
第二个参数: 线程的属性
第三个参数: 指向函数的指针, 就是将来线程需要执行的方法
第四个参数: 给第三个参数的指向函数的指针 传递的参数
void *(*functionP)(void *)
void * == id
pthread_create(<#pthread_t *restrict#>, <#const pthread_attr_t *restrict#>, <#void *(*)(void *)#>, <#void *restrict#>)
一般情况下C语言中的类型都是以 _t或者Ref结尾
pthread_t threadId;
// 只要create一次就会创建一个新的线程
pthread_create(&threadId , NULL, &demo, "name");
- a.特点：
- 1）一套通用的多线程API
- 2）适用于Unix\Linux\Windows等系统
- 3）跨平台\可移植
- 4）使用难度大
- b.使用语言：c语言
- c.使用频率：几乎不用
- d.线程生命周期：由程序员进行管理
NSThread
- 一个NSThread对象就代表一条线程
- 创建、启动线程
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
[thread start];
// 线程一启动，就会在线程thread中执行self的run方法
主线程相关用法
+ (NSThread *)mainThread; // 获得主线程
- (BOOL)isMainThread; // 是否为主线程
+ (BOOL)isMainThread; // 是否为主线程
- 获得当前线程
NSThread *current = [NSThread currentThread];
线程的名字
- (void)setName:(NSString *)n;
- (NSString *)name;
- 其他创建线程方式
创建线程后自动启动线程
[NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
隐式创建并启动线程
[self performSelectorInBackground:@selector(run) withObject:nil];
上述2种创建线程方式的优缺点
优点：简单快捷
缺点：无法对线程进行更详细的设置
启动线程
- (void)start;
// 进入就绪状态 -> 运行状态。当线程任务执行完毕，自动进入死亡状态
阻塞（暂停）线程
+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;
// 进入阻塞状态
强制停止线程
+ (void)exit;
// 进入死亡状态
注意：一旦线程停止（死亡）了，就不能再次开启任务
- （1）NSThread的基本使用
//第一种创建线程的方式：alloc init.
//特点：需要手动开启线程，可以拿到线程对象进行详细设置
//创建线程
/*
第一个参数：目标对象
第二个参数：选择器，线程启动要调用哪个方法
第三个参数：前面方法要接收的参数（最多只能接收一个参数，没有则传nil）
*/
NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(run:) object:@"wendingding"];
//启动线程
[thread start];
//第二种创建线程的方式：分离出一条子线程
//特点：自动启动线程，无法对线程进行更详细的设置
/*
第一个参数：线程启动调用的方法
第二个参数：目标对象
第三个参数：传递给调用方法的参数
*/
[NSThread detachNewThreadSelector:@selector(run:) toTarget:self withObject:@"我是分离出来的子线程"];
//第三种创建线程的方式：后台线程
//特点：自动启动线程，无法进行更详细设置
[self performSelectorInBackground:@selector(run:) withObject:@"我是后台线程"];
- （2）设置线程的属性
//设置线程的属性
//设置线程的名称
thread.name = @"线程A";
//设置线程的优先级,注意线程优先级的取值范围为0.0~1.0之间，1.0表示线程的优先级最高,如果不设置该值，那么理想状态下默认为0.5
thread.threadPriority = 1.0;
- （3）线程的状态
//线程的各种状态：新建-就绪-运行-阻塞-死亡
//常用的控制线程状态的方法
[NSThread exit];//退出当前线程
[NSThread sleepForTimeInterval:2.0];//阻塞线程
[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:2.0]];//阻塞线程
//注意：线程死了不能复生
-
（4）线程安全
01 前提：多个线程访问同一块资源会发生数据安全问题 02 解决方案：加互斥锁 03 相关代码：@synchronized(self){} 04 专业术语-线程同步 05 原子和非原子属性（是否对setter方法加锁） -
（5）线程间通信
-(void)touchesBegan:(nonnull NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event
{
// [self download2];
//开启一条子线程来下载图片
[NSThread detachNewThreadSelector:@selector(downloadImage) toTarget:self withObject:nil];
}
-(void)downloadImage
{
//1.确定要下载网络图片的url地址，一个url唯一对应着网络上的一个资源
NSURL *url = [NSURL URLWithString:@"http://图片的url地址"];
//2.根据url地址下载图片数据到本地（二进制数据
NSData *data = [NSData dataWithContentsOfURL:url];
//3.把下载到本地的二进制数据转换成图片
UIImage *image = [UIImage imageWithData:data];
//4.回到主线程刷新UI
//4.1 第一种方式
// [self performSelectorOnMainThread:@selector(showImage:) withObject:image waitUntilDone:YES];
//4.2 第二种方式
// [self.imageView performSelectorOnMainThread:@selector(setImage:) withObject:image waitUntilDone:YES];
//4.3 第三种方式
[self.imageView performSelector:@selector(setImage:) onThread:[NSThread mainThread] withObject:image waitUntilDone:YES];
}
- （6）如何计算代码段的执行时间
//第一种方法
NSDate *start = [NSDate date];
//2.根据url地址下载图片数据到本地（二进制数据）
NSData *data = [NSData dataWithContentsOfURL:url];
NSDate *end = [NSDate date];
NSLog(@"第二步操作花费的时间为%f",[end timeIntervalSinceDate:start]);
//第二种方法
CFTimeInterval start = CFAbsoluteTimeGetCurrent();
NSData *data = [NSData dataWithContentsOfURL:url];
CFTimeInterval end = CFAbsoluteTimeGetCurrent();
NSLog(@"第二步操作花费的时间为%f",end - start);
- NSThread
- a.特点：
- 1）使用更加面向对象
- 2）简单易用，可直接操作线程对象
- b.使用语言：OC语言
- c.使用频率：偶尔使用
- d.线程生命周期：由程序员进行管理
多线程的安全隐患
- 资源共享,1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源,比如多个线程访问同一个对象、同一个变量、同一个文件,当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题
-
图示
-
互斥锁使用格式
@synchronized(锁对象) { // 需要锁定的代码 }
注意：锁定1份代码只用1把锁，用多把锁是无效的 -
互斥锁的优缺点
优点：能有效防止因多线程抢夺资源造成的数据安全问题
缺点：需要消耗大量的CPU资源 -
互斥锁的使用前提：多条线程抢夺同一块资源
-
相关专业术语：线程同步
线程同步的意思是：多条线程在同一条线上执行（按顺序地执行任务）
互斥锁，就是使用了线程同步技术
原子和非原子
-
OC在定义属性时有nonatomic和atomic两种选择
atomic：原子属性，为setter方法加锁（默认就是atomic）
nonatomic：非原子属性，不会为setter方法加锁 -
原子和非原子的选择
-
nonatomic和atomic对比
atomic：线程安全，需要消耗大量的资源
nonatomic：非线程安全，适合内存小的移动设备 -
iOS开发的建议,所有属性都声明为nonatomic,尽量避免多线程抢夺同一块资源,尽量将加锁、资源抢夺的业务逻辑交给服务器端处理，减小移动客户端的压力
线程间通信
-
在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;
- 线程间通信示例
从子线程回到主线程
dispatch_async(
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行耗时的异步操作...
dispatch_async(dispatch_get_main_queue(), ^{
// 回到主线程，执行UI刷新操作
});
});
- 图例
GCD
简介
- 全称是Grand Central Dispatch，可译为“牛逼的中枢调度器”
纯C语言，提供了非常多强大的函数 - GCD的优势
GCD是苹果公司为多核的并行运算提出的解决方案
GCD会自动利用更多的CPU内核（比如双核、四核）
GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
-
GCD中有2个核心概念
-
任务：执行什么操作
-
队列：用来存放任务
-
GCD的使用就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);
GCD中还有个用来执行任务的函数：
dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行,这个queue不能是全局的并发队列
-
同步和异步的区别
同步：只能在当前线程中执行任务，不具备开启新线程的能力
异步：可以在新的线程中执行任务，具备开启新线程的能力 -
队列的类型
-
GCD的队列可以分为2大类型
-
并发队列（ConcurrentDispatchQueue）可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）,并发功能只有在异步（dispatch_async）函数下才有效
-
串行队列（Serial Dispatch Queue）
让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务） -
有4个术语比较容易混淆：同步、异步、并发、串行
-
同步和异步主要影响：能不能开启新的线程
-
同步：只是在当前线程中执行任务，不具备开启新线程的能力
-
异步：可以在新的线程中执行任务，具备开启新线程的能力
-
并发和串行主要影响：任务的执行方式
-
并发：允许多个任务并发（同时）执行
-
串行：一个任务执行完毕后，再执行下一个任务
-
并发队列
使用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);
GCD默认已经提供了全局的并发队列，供整个应用使用，可以无需手动创建
使用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);
全局并发队列的优先级
#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 // 后台
- 串行队列
使用dispatch_queue_create函数创建串行队列
// 创建串行队列（队列类型传递NULL或者DISPATCH_QUEUE_SERIAL）
dispatch_queue_t queue = dispatch_queue_create("com.name", NULL);
使用主队列（跟主线程相关联的队列）
主队列是GCD自带的一种特殊的串行队列
放在主队列中的任务，都会放到主线程中执行
使用dispatch_get_main_queue()获得主队列
dispatch_queue_t queue = dispatch_get_main_queue();
-
（1）GCD基本知识
01 两个核心概念-队列和任务
02 同步函数和异步函数 -
（2）GCD基本使用【重点】
01 异步函数+并发队列：开启多条线程，并发执行任务
1.获取全局的并发队列
dispatch_queue_t queue = dispatch_get_global_queue(0 , 0);
2.添加任务到队列
文档说明是FIFO原则, 先进先出
打印结果不正确的原因: 线程的执行速度可能不一样, 有得快一些, 有的慢一些
dispatch_async(queue, ^{
NSLog(@"1 - %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"2 - %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"3 - %@", [NSThread currentThread]);
});
02 异步函数+串行队列：开启一条线程，串行执行任务
异步 + 串行 = 会创建新的线程, 但是只会创建一个新的线程, 所有的任务都在这一个新的线程中执行
异步任务, 会先执行完所有的代码, 再在子线程中执行任务
- (void)asyncSerial
{
1.创建队列
dispatch_queue_t queue = dispatch_queue_create("name", DISPATCH_QUEUE_SERIAL);
2.添加任务
dispatch_async(queue, ^{
NSLog(@"1 - %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"2 - %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"3 - %@", [NSThread currentThread]);
});
NSLog(@"%s", __func__);
}
03 同步函数+并发队列：不开线程，串行执行任务
同步 + 并行 = 不会开启新的线程
注意: 能不能开启新的线程, 和并行/串行没有关系, 只要函数是同步还是异步
- (void)syncConcurrent
{
// 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]);
});
NSLog(@"%s", __func__);
}
04 同步函数+串行队列：不开线程，串行执行任务
同步 + 串行 = 不会创建新的线程
注意: 如果是同步函数, 只要代码执行到了同步函数的那一行, 就会立即执行任务, 只有任务执行完毕才会继续往后执行
- (void)syncSerial
{
// 1.创建队列
正是因为线程默认就是串行, 所以创建串行队列的时候, 队列类型可以不传值
// dispatch_queue_t queue = dispatch_queue_create("name", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue = dispatch_queue_create("name", NULL);
// 2.添加任务
dispatch_sync(queue, ^{
NSLog(@"1 - %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"2 - %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"3 - %@", [NSThread currentThread]);
});
NSLog(@"%s", __func__);
}
05 异步函数+主队列：不开线程，在主线程中串行执行任务
- (void)asyncMain
{
主队列, 只要将任务放到主队列中, 那么任务就会在主线程中执行
dispatch_queue_t queue = dispatch_get_main_queue();
如果任务放在主队列中, 哪怕是异步方法也不会创建新的线程
dispatch_async(queue, ^{
NSLog(@"1 - %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"2 - %@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"3 - %@", [NSThread currentThread]);
});
}
06 同步函数+主队列：不开线程，串行执行任务（注意死锁发生）
同步 + 主队列 = 需要记住的就一点: 同步函数不能搭配主队列使用
注意: 如果是在子线程中调用同步函数 + 主对列 是可以执行的
- (void)syncMian
{
// 主队列, 只要将任务放到主队列中, 那么任务就会在主线程中执行
dispatch_queue_t queue = dispatch_get_main_queue();
// 需要记住的就一点: 同步函数不能搭配主队列使用
dispatch_sync(queue, ^{
NSLog(@"1 - %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"2 - %@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"3 - %@", [NSThread currentThread]);
});
NSLog(@"++++++++++++++");
}
07 注意同步函数和异步函数在执行顺序上面的差异
- （3）GCD线程间通信
//0.获取一个全局的队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
//1.先开启一个线程，把下载图片的操作放在子线程中处理
dispatch_async(queue, ^{
//2.下载图片
NSURL *url = [NSURL URLWithString:@"http://h.hiphotos.baidu.com/zhidao/pic/item/6a63f6246b600c3320b14bb3184c510fd8f9a185.jpg"];
NSData *data = [NSData dataWithContentsOfURL:url];
UIImage *image = [UIImage imageWithData:data];
NSLog(@"下载操作所在的线程--%@",[NSThread currentThread]);
//3.回到主线程刷新UI
dispatch_async(dispatch_get_main_queue(), ^{
self.imageView.image = image;
//打印查看当前线程
NSLog(@"刷新UI---%@",[NSThread currentThread]);
});
});
- （4）GCD其它常用函数
01 栅栏函数（控制任务的执行顺序）
dispatch_barrier_async(queue, ^{
NSLog(@"--dispatch_barrier_async-");
});
02 延迟执行（延迟·控制在哪个线程执行）
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"---%@",[NSThread currentThread]);
});
iOS常见的延时执行
调用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秒后执行这里的代码...
});
使用NSTimer
[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(test) userInfo:nil repeats:NO];
03 一次性代码（注意不能放到懒加载）
-(void)once
{
//整个程序运行过程中只会执行一次
//onceToken用来记录该部分的代码是否被执行过
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"-----");
});
}
使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});
04 快速迭代（开多个线程并发完成迭代操作）
dispatch_apply(subpaths.count, queue, ^(size_t index) {
});
使用dispatch_apply函数能进行快速迭代遍历
dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index){
// 执行10次代码，index顺序不确定
});
05 队列组（同栅栏函数）
//创建队列组
dispatch_group_t group = dispatch_group_create();
//队列组中的任务执行完毕之后，执行该函数
dispatch_group_notify(dispatch_group_t group,
dispatch_queue_t queue,
dispatch_block_t block);
有这么1种需求
首先：分别异步执行2个耗时的操作
其次：等2个异步操作都执行完毕后，再回到主线程执行操作
如果想要快速高效地实现上述需求，可以考虑用队列组
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(), ^{
// 等前面的异步操作都执行完毕后，回到主线程...
});
补充
使用Crearte函数创建的并发队列和全局并发队列的主要区别：
1.全局并发队列在整个应用程序中本身是默认存在的，并且对应有高优先级、默认优先级、低优先级和后台优先级一共四个并发队列，我们只是选择其中的一个直接拿来用。而Crearte函数是实打实的从头开始去创建一个队列。
2.在iOS6.0之前，在GCD中凡是使用了带Crearte和retain的函数在最后都需要做一次release操作。而主队列和全局并发队列不需要我们手动release。当然了，在iOS6.0之后GCD已经被纳入到了ARC的内存管理范畴中，即便是使用retain或者create函数创建的对象也不再需要开发人员手动释放，我们像对待普通OC对象一样对待GCD就OK。
3.在使用栅栏函数的时候，苹果官方明确规定栅栏函数只有在和使用create函数自己的创建的并发队列一起使用的时候才有效（没有给出具体原因）
4.其它区别涉及到XUN内核的系统级线程编程，不一一列举。
5.给出一些参考资料（可以自行研究）：
GCDAPI:https://developer.apple.com/library/ios/documentation/Performance/Reference/GCD_libdispatch_Ref/index.html#//apple_ref/c/func/dispatch_queue_create
Libdispatch版本源码：http://www.opensource.apple.com/source/libdispatch/libdispatch-187.5/
XCODE7 补充
在想从网上下载的,显示真实的图片,必须在info.plist添加1个key
网友评论