前言:
最近想回顾一下多线程问题,看到一篇文章写的非常详细,为了便于以后查找以及加深印象,就照着原文摘录了下文,原著勿怪:
原文地址:http://www.cocoachina.com/ios/20170707/19769.html
一,多线程的基本概念
进程: 可以理解成一个运行中的应用程序,是系统进行资源分配和调度的基本单位,是操作系统结构的基础,主要管理资源.
线程: 是进程的基本执行单元,一个进程对应多个线程.
主线程: 处理UI,所有更新UI的操作都必须在主线程中执行,不要把耗时操作放在主线程,会卡界面.
多线程: 在同一时刻,一个CPU只能处理1条线程,但是CPU可以在多条线程之间快速切换,只要切换的足够快,就造成了多线程一同执行的假象.
多线程是通过提高资源使用率来提高总体的效率.
我们运用多线程的目的是:将耗时操作放在后台运行.
二,线程状态与生命周期
下图是线程状态示意图,从图中可以看出线程的生命周期是: 新建 -就绪 -运行 - 阻塞 - 死亡
下面是生命周期的每一步:
新建: 实例化线程对象.
就绪: 向线程对象发送start消息,线程对象被加入线程池等待CPU调度.
运行: CPU负责调度可调度线程池中线程的执行.线程执行完成前,状态可能会在就绪和运行之间来回切换.就绪和运行之间的状态变化由CPU负责,程序不能干预.
阻塞: 当满足某个预定条件时,可以使用休眠或锁,阻塞线程执行,sleepForTimeInterval(休眠指定时间), sleepUntilDate(休眠到指定日期),@synchronized(self):(互斥锁).
还有线程的exit和cancel.
[NSThread exit]:一旦强行终止线程,后续的所有代码都不会被执行.
[thread cancel]取消: 并不会直接取消线程,只是给线程添加isCancelled标记.
三,多线程的四种解决方案
多线程的四种解决方案分别是:pthread,NSThread, GCD,NSOperation.
下面是对这四种方案进行了解读和对比.
四,线程安全问题
当多个线程访问同一块资源时,很容易引发数据错乱和数据安全问题.就好比几个人在同一时修改一个表格,造成数据的错乱.
解决多线程安全问题的方法
方法一: 互斥锁(同步锁)
@synchronized(锁对象) {
// 需要锁定的代码
}
判断的时候锁对象要存在,如果代码中只有一个地方需要加锁,大多时候使用self作为锁对象,这样可以避免单独再创建一个锁对象.
加了互斥锁的代码,当新线程访问时,如果发现其他线程正在执行锁定的代码,新线程就会进入休眠
方法二: 自旋锁
加了自旋锁,当新线程访问代码时,如果发现其他线程正在锁定代码,新线程会用死循环的方式,一直等待锁定的代码执行完成.相当于不停尝试执行代码,比较小号性能.
属性修饰atomic本身就是一把自旋锁.
下面说一下属性修饰nonatomic 和atomic
nonatomic 非原子性的,同一时间可以有很多线程读和写.
atomic原子属性(线程安全), 保证同一时间只有一个县城能够写入(但是同一个时间多个线程都可以取值),atomic本身就有一把锁(自旋锁).
atomic: 线程安全,需消耗大量的资源
nonatomic: 非线程安全,不过效率更高,一般用nonatomic
五,NSThread的使用
No.1:NTHread创建线程
NSThread有三种创建方式:
init方式
detachNewThreadSelector创建好之后自动自动
pefromSelectorInBackground创建好之后也是直接启动
/** 方法一, 需要Start */
NSThread *thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"NSThread1"];
//线程加入线程池等待CPU调度,时间很快,几乎是立刻执行
[thread1 start];
/** 方法二, 创建好之后自动启动 */
[NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:@"NSThread2"];
/** 隐式创建, 直接启动 */
[self performSelectorInBackground:@selector(doSomething3:) withObject:@"NSThread3"];
No.2:NSThread的类方法
返回当前线程
// 当前线程
[NSThread currentThread];
NSLog(@"%@",[NSThread currentThread]);
// 如果number=1，则表示在主线程，否则是子线程
打印结果：{number = 1, name = main}
阻塞休眠
//休眠多久
[NSThread sleepForTimeInterval:2];
//休眠到指定时间
[NSThread sleepUntilDate:[NSDate date]];
类方法补充
//退出线程
[NSThread exit];
//判断当前线程是否为主线程
[NSThread isMainThread];
//判断当前线程是否是多线程
[NSThread isMultiThreaded];
//主线程的对象
NSThread *mainThread = [NSThread mainThread];
No.3:NSThread的一些属性
//线程是否在执行
thread.isExecuting;
//线程是否被取消
thread.isCancelled;
//线程是否完成
thread.isFinished;
//是否是主线程
thread.isMainThread;
//线程的优先级，取值范围0.0到1.0，默认优先级0.5，1.0表示最高优先级，优先级高，CPU调度的频率高
thread.threadPriority;
六,GCD的理解与使用
No.1:GCD的特点
GCD会自动利用更多的CPU内核;
GCD自动管理线程的生命周期(创建线程, 调度任务, 销毁线程);
程序员只需要告诉GCD想要如何执行什么任务,不需要任何线程管理代码.
No.2: GCD的基本概念
任务 (block) : 任务就是将要在线程中执行的代码,将这段代码用block封装好,然后将这个任务添加到指定的执行方式(同步执行,异步执行), 等待CPU从队列中取出任务放到对应的线程中执行.
同步 (sync):一个接着一个,前一个没有执行完, 后面的不能执行,不开线程.
异步 (async) : 开启多线程, 任务同一时间可以一起执行. 异步是多线程的代名词.
队列 : 装载线程任务的队形结. (系统以先进先出的方式调度队列中的任务执行). 在GCD中有两种队列: 串行队列和并发队列.
串行队列 :线程只能依次有序的执行.
并发队列 :线程可以同时一起执行.实际上是CPU在多条线程之间快速切换.(并发只有在异步(dispatch_async)函数下才有效).
GCD总结 : 将任务(要在线程中执行的操作block) 添加到队列(自己创建或使用全局并发队列),并且指定任务的执行方式(异步dispatch_async, 同步dispatch_sync).
No.3 : 队列的创建方法
使用dispatch_queue_create来创建队列对象,传入两个参数,第一个表示队列的唯一标示符,可为空.第二个参数用来标示串行队列(DISPATCH_QUEUE_SERIAL) 或并发队列 (DISPATCH_QUEUE_CONCURRENT).
//串行队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
//并发队列
dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
GCD队列还有另外两种:
主队列,全局并发队列
主队列 :主队列是负责在主线程上调度任务, 如果在主线程上已经有任务正在执行,主队列会等到主线程空闲后再调度任务, 通常是返回主线程更新UI的时候使用. dispatch_get_main_queue()
dispatch_async(dispatch_get_global_queue(0, 0), ^{
//耗时操作放在这里
dispatch_async(dispatch_get_main_queue(), ^{
//回到主线程进行UI操作
});
});
全局并发队列: 全局并发队列就是一个并发队列,是为了让我们更方便的使用多线程.
dispatch_get_global_queue(0,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 // 后台优先级
//iOS8开始使用服务质量，现在获取全局并发队列时，可以直接传0
dispatch_get_global_queue(0, 0);
No.4:同步/异步/任务、创建方式
同步 (sync) 使用dispatch_sync来表示
异步 (sync) 使用dispatch_async来表示
任务就是将要在线程中执行的代码, 将这段代码用block封装好.
代码如下:
//同步执行任务
dispatch_sync(dispatch_get_global_queue(0, 0), ^{
//任务放在这个block里
NSLog(@"我是同步执行任务");
});
//异步执行任务
dispatch_async(dispatch_get_global_queue(0, 0), ^{
//
//任务放在这个block里
NSLog(@"我是异步执行任务");
});
No.5: GCD的使用
由于有多种队列(串行/并发/主队列) 和两种执行方式 (同步/异步),所以他们之间可以有多种组合方式.
1, 串行同步
2,串行异步
3,并发同步
4,并发异步
5,主队列同步
6,主队列异步
◎串行同步
执行完一个任务,在执行下一个任务,不开启新线程.
/** 串行同步 */
- (void)syncSerial {
NSLog(@"\n\n**************串行同步***************\n\n");
// 串行队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 同步执行
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"串行同步1 %@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"串行同步2 %@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"串行同步3 %@",[NSThread currentThread]);
}
});
}
输出结果为顺序执行,都在主线程:
串行同步1 {number = 1, name = main}
串行同步1 {number = 1, name = main}
串行同步1 {number = 1, name = main}
串行同步2 {number = 1, name = main}
串行同步2 {number = 1, name = main}
串行同步2 {number = 1, name = main}
串行同步3 {number = 1, name = main}
串行同步3 {number = 1, name = main}
串行同步3 {number = 1, name = main}
◎串行异步
开启新线程,但因为任务是串行的,所以还是按顺序执行完任务.
/** 串行异步 */
- (void)asyncSerial {
NSLog(@"\n\n**************串行异步***************\n\n");
// 串行队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 异步执行
dispatch_async(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"串行异步1 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"串行异步2 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"串行异步3 %@",[NSThread currentThread]);
}
});
}
输出结果为顺序执行,有不同线程:
串行异步1 {number = 3, name = (null)}
串行异步1 {number = 3, name = (null)}
串行异步1 {number = 3, name = (null)}
串行异步2 {number = 3, name = (null)}
串行异步2 {number = 3, name = (null)}
串行异步2 {number = 3, name = (null)}
串行异步3 {number = 3, name = (null)}
串行异步3 {number = 3, name = (null)}
串行异步3 {number = 3, name = (null)}
◎并发同步
因为是同步的,所以执行完一个任务,再执行下一个任务.不会开启新线程
/** 并发同步 */
- (void)syncConcurrent {
NSLog(@"\n\n**************并发同步***************\n\n");
// 并发队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
// 同步执行
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"并发同步1 %@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"并发同步2 %@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"并发同步3 %@",[NSThread currentThread]);
}
});
}
输出结果为顺序执行,都在主线程:
并发同步1 {number = 1, name = main}
并发同步1 {number = 1, name = main}
并发同步1 {number = 1, name = main}
并发同步2 {number = 1, name = main}
并发同步2 {number = 1, name = main}
并发同步2 {number = 1, name = main}
并发同步3 {number = 1, name = main}
并发同步3 {number = 1, name = main}
并发同步3 {number = 1, name = main}
◎并发异步
任务交替执行,开启多线程.
/** 并发异步 */
- (void)asyncConcurrent {
NSLog(@"\n\n**************并发异步***************\n\n");
// 并发队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
// 同步执行
dispatch_async(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"并发异步1 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"并发异步2 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"并发异步3 %@",[NSThread currentThread]);
}
});
}
输出结果为无序执行,有多条线程:
并发异步1 {number = 3, name = (null)}
并发异步2 {number = 4, name = (null)}
并发异步3 {number = 5, name = (null)}
并发异步1 {number = 3, name = (null)}
并发异步2 {number = 4, name = (null)}
并发异步3 {number = 5, name = (null)}
并发异步1 {number = 3, name = (null)}
并发异步2 {number = 4, name = (null)}
并发异步3 {number = 5, name = (null)}
◎ 主队列同步
如果在主线程中运用这种方式,则会发生死锁,程序崩溃.
/** 主队列同步 */
- (void)syncMain {
NSLog(@"\n\n**************主队列同步，放到主线程会死锁***************\n\n");
// 主队列
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"主队列同步1 %@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"主队列同步2 %@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"主队列同步3 %@",[NSThread currentThread]);
}
});
}
主队列同步造成死锁的原因
1,如果在主线程中运用主队列同步,也就是把任务放到主线程的队列中.
2,而同步对于任务是立刻执行的,那么当把第一个任务放进主队列时,他就立马执行
3,可是主线程现在正在处理syncMain方法,任务需要等sybcMain执行完才能执行.
4,sysnMain执行到第一个任务的时候,又要等第一个任务执行完才能往下执行第二个和第三个任务.
5,这样syncMain方法和第一个任务就开始了互相等待,形成了死锁.
◎主队列异步
在主线程中任务按顺序执行
/** 主队列异步 */
- (void)asyncMain {
NSLog(@"\n\n**************主队列异步***************\n\n");
// 主队列
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"主队列异步1 %@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"主队列异步2 %@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"主队列异步3 %@",[NSThread currentThread]);
}
});
}
输出结果为在主线程中按顺序执行:
主队列异步1 {number = 1, name = main}
主队列异步1 {number = 1, name = main}
主队列异步1 {number = 1, name = main}
主队列异步2 {number = 1, name = main}
主队列异步2 {number = 1, name = main}
主队列异步2 {number = 1, name = main}
主队列异步3 {number = 1, name = main}
主队列异步3 {number = 1, name = main}
主队列异步3 {number = 1, name = main}
◎GCD之间的通讯
开发中需要在主线程上进行UI的相关操作,通常会把一些耗时的操作放在其他线程,比如说图片文件下载等耗时操作.当完成了耗时操作之后,需要回到主线程进行UI的处理,这里用到了线程之间的通讯.
- (IBAction)communicationBetweenThread:(id)sender {
// 异步
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 耗时操作放在这里，例如下载图片。（运用线程休眠两秒来模拟耗时操作）
[NSThread sleepForTimeInterval:2];
NSString *picURLStr = @"http://www.bangmangxuan.net/uploads/allimg/160320/74-160320130500.jpg";
NSURL *picURL = [NSURL URLWithString:picURLStr];
NSData *picData = [NSData dataWithContentsOfURL:picURL];
UIImage *image = [UIImage imageWithData:picData];
// 回到主线程处理UI
dispatch_async(dispatch_get_main_queue(), ^{
// 在主线程上添加图片
self.imageView.image = image;
});
});
}
上面的代码实在新开的线程中进行图片下载,下载完成之后回到主线程显示图片.
◎GCD栅栏
当任务需要异步进行,但是这些任务需要分成两组来完成,第一组完成之后才能进行第二组, 这时候就用到了GCD的栅栏方法
dispatch_barrier_async.
- (IBAction)barrierGCD:(id)sender {
// 并发队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
// 异步执行
dispatch_async(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"栅栏：并发异步1 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"栅栏：并发异步2 %@",[NSThread currentThread]);
}
});
dispatch_barrier_async(queue, ^{
NSLog(@"------------barrier------------%@", [NSThread currentThread]);
NSLog(@"******* 并发异步执行，但是34一定在12后面 *********");
});
dispatch_async(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"栅栏：并发异步3 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for(int i = 0; i < 3; i++) {
NSLog(@"栅栏：并发异步4 %@",[NSThread currentThread]);
}
});
}
上面的代码打印结果如下,开了多条线程,所有任务都是并发异步进行.但是第一组完成之后,才会进行第二组的操作.
栅栏：并发异步1 {number = 3, name = (null)}
栅栏：并发异步2 {number = 6, name = (null)}
栅栏：并发异步1 {number = 3, name = (null)}
栅栏：并发异步2 {number = 6, name = (null)}
栅栏：并发异步1 {number = 3, name = (null)}
栅栏：并发异步2 {number = 6, name = (null)}
------------barrier------------{number = 6, name = (null)}
******* 并发异步执行，但是34一定在12后面 *********
栅栏：并发异步4 {number = 3, name = (null)}
栅栏：并发异步3 {number = 6, name = (null)}
栅栏：并发异步4 {number = 3, name = (null)}
栅栏：并发异步3 {number = 6, name = (null)}
栅栏：并发异步4 {number = 3, name = (null)}
栅栏：并发异步3 {number = 6, name = (null)}
◎GCD延时执行
当需要等待一会再执行,就可以用到这个方法了:dispatch_after
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 5秒后异步执行
NSLog(@"我已经等待了5秒！");
});
GCD实现代码只执行一次
使用dispatch_once能保证某段代码在程序运行过程中只被执行1次。可以用来设计单例。
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"程序运行过程中我只执行了一次！");
});
◎GCD快速迭代
GCD有一个快速迭代的方法dispatch_apply, dispatch_apply可以同时遍历多个数字
- (IBAction)applyGCD:(id)sender {
NSLog(@"\n\n************** GCD快速迭代 ***************\n\n");
// 并发队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
// dispatch_apply几乎同时遍历多个数字
dispatch_apply(7, queue, ^(size_t index) {
NSLog(@"dispatch_apply：%zd======%@",index, [NSThread currentThread]);
});
}
打印结果如下:
dispatch_apply：0======{number = 1, name = main}
dispatch_apply：1======{number = 1, name = main}
dispatch_apply：2======{number = 1, name = main}
dispatch_apply：3======{number = 1, name = main}
dispatch_apply：4======{number = 1, name = main}
dispatch_apply：5======{number = 1, name = main}
dispatch_apply：6======{number = 1, name = main}
◎GCD队列组
异步执行几个耗时操作,当这几个操作都完成之后再执行另一个操作,就可以用到队列组了.
队列组有下面几个特点:
1,所有的任务会并发的执行(不按顺序).
2,所有的异步函数都添加到队列中,然后再纳入队列组的监听范围.
3,使用dispatch_group_notify函数,来监听上面的任务是否完成,如果完成,就调用这个方法.
队列组示例代码:
- (IBAction)groupAction:(id)sender {
NSLog(@"\n\n**************GCD队列组***************\n");
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_group_async(group, queue, ^{
NSLog(@"队列组：有一个耗时操作完成！");
});
dispatch_group_async(group, queue, ^{
NSLog(@"队列组：有一个耗时操作完成！");
});
dispatch_group_async(group, queue, ^{
NSLog(@"队列组：有一个耗时操作完成！");
});
dispatch_group_notify(group, queue, ^{
NSLog(@"队列组：前面的耗时操作都完成了，回到主线程进行相关操作");
});
}
打印结果如下:
队列组：有一个耗时操作完成！
队列组：有一个耗时操作完成！
队列组：有一个耗时操作完成！
队列组：前面的耗时操作都完成了，回到主线程进行相关操作
至此,GCD的相关操作内容叙述完毕,下面继续学习NSOperation.
七, NSOperation的理解和使用
No.1: NSOperation简介
NSOperation是基于GCD之上的更高一层封装,NSOperation需要配合NSOperationQueue来实现多线程.
NSOperation实现多线程步骤如下:
1,创建任务: 先将需要执行的操作封装到NSOperation对象中.
2,创建队列: 创建NSOperationQueue.
3,将任务加入到队列中: 将NSOperation对象添加到NSOperationQueue中
需要注意的是,NAOperation是个抽象类,实际运用时需要使用它的子类,有三种方式:
1,使用子类NSInvocationOperation
2,使用子类NSBlockOperation
3,定义继承自NSOperation的子类,通过内部响应的方法来封装任务.
No.2:NSOperation的三种创建方式
◎NSInvocationOperation的使用
创建NSInvocationd对象,并关联方法,之后start.
- (void)testNSInvocationOperation {
// 创建NSInvocationOperation
NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperation) object:nil];
// 开始执行操作
[invocationOperation start];
}
- (void)invocationOperation {
NSLog(@"NSInvocationOperation包含的任务，没有加入队列========%@", [NSThread currentThread]);
}
打印结果如下,得到结论: 程序在主线程执行,没有开启新线程.
这是因为NSOperation多线程的使用需要配合队列NSOperationQueue,后面会讲到NSOperationQueue的使用.
NSInvocationOperation包含的任务，没有加入队列========{number = 1, name = main}
◎NSBlockOperation的使用
把任务放到NSBlockOperation的block中,然后start.
- (void)testNSBlockOperation {
// 把任务放到block中
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"NSBlockOperation包含的任务，没有加入队列========%@", [NSThread currentThread]);
}];
[blockOperation start];
}
执行结果如下,可以看出:主线程执行,没有开启新线程.
同样的,NSBlockOperation可以配合队列NSOperationQueue来实现多线程.
NSBlockOperation包含的任务，没有加入队列========{number = 1, name = main}
但是NSBlockOperation有一个addExecutionBlock:,通过这个方法可以让NSBlockOperation实现多线程.
- (void)testNSBlockOperationExecution {
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"NSBlockOperation运用addExecutionBlock主任务========%@", [NSThread currentThread]);
}];
[blockOperation addExecutionBlock:^{
NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务1========%@", [NSThread currentThread]);
}];
[blockOperation addExecutionBlock:^{
NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务2========%@", [NSThread currentThread]);
}];
[blockOperation addExecutionBlock:^{
NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务3========%@", [NSThread currentThread]);
}];
[blockOperation start];
}
执行结果如下,可以看出,NSBlockOperation创建时block中的任务是在主线程中执行,而运行addExecutionBlock加入的任务是在子线程执行的.
NSBlockOperation运用addExecutionBlock========{number = 1, name = main}
addExecutionBlock方法添加任务1========{number = 3, name = (null)}
addExecutionBlock方法添加任务3========{number = 5, name = (null)}
addExecutionBlock方法添加任务2========{number = 4, name = (null)}
◎运用继承自NSOperation的子类
首先我们定义一个继承自NSOperation的类,然后重写他的main方法, 之后就可以使用这个子类来进行相关操作了.
/*******************"WHOperation.h"*************************/
#import @interface WHOperation : NSOperation
@end
/*******************"WHOperation.m"*************************/
#import "WHOperation.h"
@implementation WHOperation
- (void)main {
for(int i = 0; i < 3; i++) {
NSLog(@"NSOperation的子类WHOperation======%@",[NSThread currentThread]);
}
}
@end
/*****************回到主控制器使用WHOperation**********************/
- (void)testWHOperation {
WHOperation *operation = [[WHOperation alloc] init];
[operation start];
}
运行结果如下,依然是在主线程执行
SOperation的子类WHOperation======{number = 1, name = main}
NSOperation的子类WHOperation======{number = 1, name = main}
NSOperation的子类WHOperation======{number = 1, name = main}
所以NSOperation是需要配合NSOperationQueue来实现多线程的,下面来说一下队列NSOperationQueue.
No.3: 队列NSOperationQueue
NSOperationQueue只有两种队列:主队列、其他队列.其他队列包含了串行和并发.
主队列的创建如下,主队列上的任务是在主线程中执行的
NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
其他队列(非主队列)的创建如下,加入到"非主队列的任务默认就是并发", 开启多线程
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
注意:
1,非主队列(其他队列)可以实现串行或并行.
2,队列NSOperationQueue有一个参数叫最大并发数: maxConcurrentOperationCount.
3,maxConcurrentOperationCount默认为-1,直接并发执行,所以加入到"非主队列"中的任务默认就是并发,开启多线程.
4,当maxConcurrentOperationCount为1时,则表示不开线程,也就是串行.
5,当maxConcurrentOperationCount大于1时,进行并发执行.
6,系统对对打并发数有一个限制,所以即使程序员把maxConcurrentOperationCount设置的很大,系统也会自动调整.所以把最大并发数设置的很大是没有意义的.
No.4: NSOperation + NSOperationQueue
把任务加入队列,这才是NSOperation的常规使用
◎addOperation添加任务到队列
先创建好任务,然后用addOperation:方法把任务添加到队列,示例代码如下:
- (void)testOperationQueue {
// 创建队列，默认并发
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 创建操作，NSInvocationOperation
NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAddOperation) object:nil];
// 创建操作，NSBlockOperation
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
for(int i = 0; i < 3; i++) {
NSLog(@"addOperation把任务添加到队列======%@", [NSThread currentThread]);
}
}];
[queue addOperation:invocationOperation];
[queue addOperation:blockOperation];
}
- (void)invocationOperationAddOperation {
NSLog(@"invocationOperation===aaddOperation把任务添加到队列====%@", [NSThread currentThread]);
}
运行结果如下,可以看出,任务都是在子线程执行的,开启了新线程!
invocationOperation===addOperation把任务添加到队列===={number = 4, name = (null)}
addOperation把任务添加到队列======{number = 3, name = (null)}
addOperation把任务添加到队列======{number = 3, name = (null)}
addOperation把任务添加到队列======{number = 3, name = (null)}
◎这是一个更方便的把任务添加到队列的方法,直接把任务写到block中,添加到任务中.
- (void)testAddOperationWithBlock {
// 创建队列，默认并发
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 添加操作到队列
[queue addOperationWithBlock:^{
for(int i = 0; i < 3; i++) {
NSLog(@"addOperationWithBlock把任务添加到队列======%@", [NSThread currentThread]);
}
}];
}
运行结果如下,任务确实是在子线程中执行
addOperationWithBlock把任务添加到队列======{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列======{number = 3, name = (null)}
addOperationWithBlock把任务添加到队列======{number = 3, name = (null)}
◎运用最大并发数实现串行
上面已经说过,可以运用队列的的属性maxConcurrentOperationCount(最大并发数)来实现串行,值需要把它设置为1就可以了,下面我们通过代码验证一下.
- (void)testMaxConcurrentOperationCount {
// 创建队列，默认并发
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 最大并发数为1，串行
queue.maxConcurrentOperationCount = 1;
// 最大并发数为2，并发
// queue.maxConcurrentOperationCount = 2;
// 添加操作到队列
[queue addOperationWithBlock:^{
for(int i = 0; i < 3; i++) {
NSLog(@"addOperationWithBlock把任务添加到队列1======%@", [NSThread currentThread]);
}
}];
// 添加操作到队列
[queue addOperationWithBlock:^{
for(int i = 0; i < 3; i++) {
NSLog(@"addOperationWithBlock把任务添加到队列2======%@", [NSThread currentThread]);
}
}];
// 添加操作到队列
[queue addOperationWithBlock:^{
for(int i = 0; i < 3; i++) {
NSLog(@"addOperationWithBlock把任务添加到队列3======%@", [NSThread currentThread]);
}
}];
}
运行结果如下,当最大并发数为1的时候,虽然开启了线程,但是任务是顺序执行的,所以实现了串行
No.5: NSOperation的其他操作
◎取消队列NSOperationQueue的所有操作, NSOperationQueue对象方法
- (void)cancel
◎使队列暂停或继续
// 暂停队列
[queue setSuspended:YES];
◎判断队列是否暂停
- (BOOL)isSuspended
暂停和取消不是立刻当前操作,而是等当前操作执行完之后不再进行新的操作.
No.6: NSOperation的操作依赖
NSOperation有一个非常好用的方法, 就是操作依赖.可以从字面意思理解:某一个操作(operetion2)依赖于另一个操作(operation1), 只有当operation1执行完毕,才能执行operation2,这时,就是才做依赖大显身手的时候了.
- (void)testAddDependency {
// 并发队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 操作1
NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
for(int i = 0; i < 3; i++) {
NSLog(@"operation1======%@", [NSThread currentThread]);
}
}];
// 操作2
NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"****operation2依赖于operation1，只有当operation1执行完毕，operation2才会执行****");
for(int i = 0; i < 3; i++) {
NSLog(@"operation2======%@", [NSThread currentThread]);
}
}];
// 使操作2依赖于操作1
[operation2 addDependency:operation1];
// 把操作加入队列
[queue addOperation:operation1];
[queue addOperation:operation2];
}
运行结果如下,操作2总是在操作1之后运行,成功验证了上面的说法
operation1======{number = 3, name = (null)}
operation1======{number = 3, name = (null)}
operation1======{number = 3, name = (null)}
****operation2依赖于operation1，只有当operation1执行完毕，operation2才会执行****
operation2======{number = 4, name = (null)}
operation2======{number = 4, name = (null)}
operation2======{number = 4, name = (null)}
