iOS之多线程:线程的生命周期,NSThread、GCD、NSOperation的使用与总结

前言:

我负责努力,其余交给运气。

正文:

闲暇之余,把线程的问题整理一下,感觉可能会有点长,所以先自分一下章节,我将会按照以下几个小节来展开描述:

1.多线程的基本概念

2.线程的状态与生命周期

3.多线程的对比:pthread、NSThread、GCD、NSOperation

4.NSThread的使用

5.GCD的理解与使用

6.NSOperation的理解与使用

一、多线程的基本概念
  • 进程:是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。在当代面向线程设计的计算机结构中,进程是线程的容器。简单来说,进程可以看成App执行的一个实例,一个进程可以拥有多个线程。线程与进程的一个主要区别是,同一进程内的多个线程会共享部分状态,多个线程可以读写同一块内存(一个进程无法直接访问另一进程的内存)。

  • 线程:是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中最少有一个线程,也可以有多个线程,每条线程可执行不同的任务。

  • 主线程:当一个程序启动时,就有一个进程被操作系统创建,与此同时一个线程也立刻运行,该线程通常叫做程序的主线程,因为它是程序开始时就执行的,如果你需要再创建线程,那么创建的线程就是这个主线程的子线程。主线程的重要性体现在两方面:1.是产生其他子线程的线程;2.通常它必须最后完成执行比如执行各种关闭动作。

  • 多线程:在同一时刻,一个CPU只能处理1条线程,但CPU可以在多条线程之间快速的切换,只要切换的足够快,就造成了多线程一同执行的假象。而我们运用多线程的目的在于,避免阻塞主线程;多线程是通过提高资源使用率来提高系统总体的效率。

  • 最后,做个形象的比喻:一个运行的App我们可以看做是奔跑的火车(一个进程),而一个火车最少要有一个火车头(主线程,负责程序的运行,且一个进程至少包含一个线程),可以有多节车厢(多线程,每一节车厢可以看做是子线程,可执行不同的任务)。


二、线程的状态与生命周期

如下图所示,线程的生命周期是:新建、就绪、运行、阻塞、死亡:

线程状态图
  • 新建:实例化线程对象

  • 就绪:向线程对象发送start消息,线程对象被加入可调度线程池等待CPU调度。

  • 运行:CPU 负责调度可调度线程池中线程的执行。线程执行完成之前,状态可能会在就绪和运行之间来回切换。就绪和运行之间的状态变化由CPU负责,程序员不能干预。

  • 阻塞:当满足某个预定条件时,可以使用休眠或锁,阻塞线程执行。sleepForTimeInterval(休眠指定时长),sleepUntilDate(休眠到指定日期),@synchronized(self):(互斥锁等各种锁)。

  • 死亡:正常死亡,线程执行完毕。非正常死亡,当满足某个条件后,在线程内部中止执行/在主线程中止线程对象(例如:exit和cancel)

  • [NSThread exit]:一旦强行终止线程,后续的所有代码都不会被执行。

  • [thread cancel]取消:并不会直接取消线程,只是给线程对象添加 isCancelled 标记。


三、多线程的对比:pthread、NSThread、GCD、NSOperation
线程对比图

相比于pthread和NSThread,GCD和NSOperation更常用一些,所以着重说一下GCD和NSOperation:

GCD 和 NSOperation的区别主要表现在以下几方面:

  1. GCD是一套 C 语言API,执行和操作简单高效,因此NSOperation底层也通过GCD实现,这是他们之间最本质的区别.因此如果希望自定义任务,建议使用NSOperation;

  2. 依赖关系,NSOperation可以设置操作之间的依赖(可以跨队列设置),GCD无法设置依赖关系,不过可以通过同步来实现这种效果;

  3. KVO(键值对观察),NSOperation容易判断操作当前的状态(是否执行,是否取消等),对此GCD无法通过KVO进行判断;

  4. 优先级,NSOperation可以设置自身的优先级,但是优先级高的不一定先执行,GCD只能设置队列的优先级,如果要区分block任务的优先级,需要很复杂的代码才能实现;

  5. 继承,NSOperation是一个抽象类.实际开发中常用的是它的两个子类:NSInvocationOperation和NSBlockOperation,同样我们可以自定义NSOperation,GCD执行任务可以自由组装,没有继承那么高的代码复用度;

  6. 效率,直接使用GCD效率确实会更高效,NSOperation会多一点开销,但是通过NSOperation可以获得依赖,优先级,继承,键值对观察这些优势,相对于多的那么一点开销确实很划算,鱼和熊掌不可得兼,取舍在于开发者自己;

  7. 可以随时取消准备执行的任务(已经在执行的不能取消),GCD没法停止已经加入queue 的 block(虽然也能实现,但是需要很复杂的代码)

基于GCD简单高效,更强的执行能力,操作不太复杂的时候,优先选用GCD;而比较复杂的任务可以自己通过NSOperation实现.


四、NSThread的使用
4.1 NSThread的创建

NSThread有三种创建方式:

  • init 创建好之后需要start启动
  • detachNewThreadSelector 创建好之后自动启动
  • performSelectorInBackground 创建好之后直接启动

直接上代码:

- (void)showNSThread{
    /** 方法一,需要start */
    NSThread* thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"1"];
    [thread1 start];
     /** 方法二,创建好之后自动启动 */
    [NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:@"2"];
    /** 方法三,隐式创建,直接启动 */
    [self performSelectorInBackground:@selector(doSomething3:) withObject:@"3"];
}
- (void)doSomething1:(NSObject*)obj{
    NSLog(@"doSometing1 ---- obj = %@",obj);
}
- (void)doSomething2:(NSObject*)obj{
    NSLog(@"doSometing2 ---- obj = %@",obj);
}
- (void)doSomething3:(NSObject*)obj{
    NSLog(@"doSometing3 ---- obj = %@",obj);
}
4.2 NSThread的一些属性、实例方法、类方法**
  • 属性:
/**
每个线程都维护了一个键-值的字典,它可以在线程里面的任何地方被访问。
可以使用该字典来保存一些信息,这些信息在整个线程的执行过程中都保持不变。
比如,你可以使用它来存储在你的整个线程过程中 Run loop 里面多次迭代的状态信息。
NSThread实例可以使用一下方法:
NSMutableDictionary *dict = [thread threadDictionary]; 
*/
@property (readonly, retain) NSMutableDictionary *threadDictionary;

@property double threadPriority ; //优先级

/**NSQualityOfService说明:
NSQualityOfServiceUserInteractive:最高优先级,主要用于提供交互UI的操作,比如处理点击事件,绘制图像到屏幕上
NSQualityOfServiceUserInitiated:次高优先级,主要用于执行需要立即返回的任务
NSQualityOfServiceDefault:默认优先级,当没有设置优先级的时候,线程默认优先级
NSQualityOfServiceUtility:普通优先级,主要用于不需要立即返回的任务
NSQualityOfServiceBackground:后台优先级,用于完全不紧急的任务
*/
@property NSQualityOfService qualityOfService; //线程优先级

@property (nullable, copy) NSString *name;//线程名称

@property NSUInteger stackSize ;//线程使用栈区大小,默认是512K

@property (readonly, getter=isExecuting) BOOL executing;//线程是否正在执行

@property (readonly, getter=isFinished) BOOL finished;//线程是否执行结束

@property (readonly, getter=isCancelled) BOOL cancelled;//线程是否可被取消

  • 实例方法:
-(void)start; //启动线程(init创建的线程,需start启动,不自行运行)

-(BOOL)isMainThread; //是否为主线程

-(void)setName:(NSString *)n; //设置线程名称

-(void)cancel ; //取消线程

-(void)main ; //线程的入口函数

-(void)isExecuting; //判断线程是否正在执行

-(void)isFinished; //判断线程是否已经结束

-(void)isCancelled; //判断线程是否撤销
  • 类方法:
+(void)currentThread; //获取当前线程

+(BOOL)isMultiThreaded; //当前代码运行所在线程是否是子线程

+(void)sleepUntilDate:(NSDate *)date; //当前代码所在线程睡到指定时间

+(void)sleepForTimeInterval:(NSTimeInterval)ti; //当前线程睡多长时间

+(void)exit; //退出当前线程

+(double)threadPriority; //设置当前线程优先级
/**给当前线程设定优先级,调度优先级的取值范围是0.0 ~ 1.0,
默认0.5,值越大,优先级越高。*/
+(BOOL)setThreadPriority:(double)p; 
/**
线程的调用都会有函数的调用,函数的调用就会有栈返回地址的记录,
在这里返回的是函 数调用返回的虚拟地址,
说白了就是在该线程中函数调用的虚拟地址的数组
*/
+(NSArray *)callStackReturnAddresses;

+(NSArray *)callStackSymbols; //同上面的方法一样,只不过返回的是该线程调用函数的名字数字

注:callStackReturnAddress和callStackSymbols这两个函数可以同NSLog联合使用来跟踪线程的函数调用情况,是编程调试的重要手段。


五、GCD的理解与使用

5.1 GCD的基本概念

  • 任务(block):任务就是将要在线程中执行的代码,将这段代码用block封装好,然后将这个任务添加到指定的执行方式(同步执行和异步执行),等待CPU从队列中取出任务放到对应的线程中执行。

  • 同步(sync):一个接着一个,前一个没有执行完,后面不能执行,不开线程。

  • 异步(async):开启多个新线程,任务同一时间可以一起执行。异步是多线程的代名词。

  • 队列:装载线程任务的队形结构。(系统以先进先出的方式调度队列中的任务执行)。在GCD中有两种队列:串行队列和并发队列。

  • 并发队列:线程可以同时一起进行执行。实际上是CPU在多条线程之间快速的切换。(并发功能只有在异步(dispatch_async)函数下才有效)

  • 串行队列:线程只能依次有序的执行。

  • GCD总结:添加任务(线程中执行的操作block)且指定执行任务的方式(异步dispatch_async,同步dispatch_sync),并将线程添加进队列(自己创建或使用全局并发队列)。

5.2 队列的创建方式
使用dispatch_queue_create来创建队列对象,传入两个参数,第一个参数表示队列的唯一标识符,可为空。第二个参数用来表示串行队列(DISPATCH_QUEUE_SERIAL或零)或并发队列(DISPATCH_QUEUE_CONCURRENT)。

//串行队列
dispatch_queue_t queue1 = dispatch_queue_create("queue1",DISPATCH_QUEUE_SERIAL);

//并行队列
dispatch_queue_t queue2 = dispatch_queue_create("queue2",DISPATCH_QUEUE_CONCURRENT);

GCD的队列还有另外两种:

  • 主队列:dispatch_get_main_queue(),主队列负责在主线程上调度任务,如果在主线程上已经有任务正在执行,主队列会等到主线程空闲后再调度任务。通常是返回主线程更新UI的时候使用。
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);

5.3 同步、异步&任务

  • 同步(sync):使用dispatch_sync来表示
  • 异步(async):使用dispatch_async来表示。
  • 任务:就是将要在线程中执行的代码,将这段代码用block封装好。
    // 同步执行任务
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        // 任务放在这个block里
        NSLog(@"我是同步执行的任务");
    });
    // 异步执行任务
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 任务放在这个block里
        NSLog(@"我是异步执行的任务");
    });

5.4 GCD的使用
由于有多种队列(串行、并发、主队列)和两种执行方式(同步、异步),所以他们之间有多种组合方式:串行同步、串行异步、并发同步、并发异步、主队列同步、主队列异步。

  • 5.4.1 串行同步:执行完一个任务,再执行下一个任务。不开启新线程。
/** 串行同步 */
- (void)serialSynchronization{
    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    // 同步执行
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行同步1,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行同步2,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数1");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行同步3,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
}

执行结果为顺序执行,且没有开辟新线程,都在主线程,阻塞了主线程,如图:

串行同步执行结果
  • 5.4.2 串行异步:开启新线程,但因为任务是串行的,所以还是按顺序执行任务。
 /** 串行异步 */
- (void)serialAsynchronous {
    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    // 异步执行
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行异步1,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行异步2,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数1");
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行异步3,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
}

执行结果如下,因为是串行队列,所以异步线程按照顺序执行;但是异步开辟了新的子线程,所以没有阻塞主线程:

串行异步执行结果
  • 5.4.3 并发同步
/** 并发同步 */ 
- (void)concurrentSynchronization {
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    // 同步执行
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发同步1,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发同步2,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数1");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发同步3,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
}

执行结果如下,虽然我们选择的并发队列,但是因为是同步线程,所以任务依然是顺序执行,没有开辟新线程,依然在主线程上执行,且阻塞了主线程:

并发同步执行结果
  • 5.4.4 并发异步
/** 并发异步 */
- (void)concurrentAsynchronization {
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    // 异步执行
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发异步1,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发异步2,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数1");
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发异步3,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
}

执行结果如下,执行顺序无序(并发)、开辟了多条子线程、没有阻塞主线程:

并发异步执行结果
  • 5.4.5 主队列同步
/** 主队列同步 */
- (void)syncMain {
    // 主队列
    NSLog(@"主线程执行函数1");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列同步1,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列同步2,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数3");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列同步3,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数4");
}

执行结果如下,xcode8之后,不会阻塞,会崩溃。不过话说回来,主队列同步造成死锁,我们都知道是因为相互等待,可是阻塞、等待的是谁呢?这里要说的是:阻塞的是队列, 不是线程,我们可能会疑惑,为什么其他串行同步不会死锁:输出block确实也在主线程执行, 如果sync阻塞的是主线程, 那按理这样确实会死锁, 但实际上sync阻塞的是主队列, 而不是主线程。其他串行同步运行结果是, dispatch_sync运行在主队列, 而其block运行在queue队列, 虽然两个队列都是由主线程执行, 由于dispatch_sync阻塞的只是主队列, block在queue队列由主线程执行完并返回, 从而dispatch_sync返回, 之后主队列结束阻塞继续执行下面任务. 此处queue队列是运行在主线程的另一串行队列(是不是很懵~~ 哈哈~~ 看下面模拟阻塞代码会清楚一些)。

我们自己模拟出主队列阻塞可能更容易理解:

dispatch_queue_t queue = dispatch_queue_create("queue1", DISPATCH_QUEUE_SERIAL);//可以把queue理解为主队列
dispatch_sync(queue, ^{//可以把这理解为主线程
    dispatch_sync(queue, ^{//主线程中主队列同步   
    });
});

这样就把串行队列queue阻塞了.

主队列同步执行结果
  • 5.4.6 主队列异步
/** 主队列异步 */
- (void)asyncMain {
    // 主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列异步1,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列异步2,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数1");
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列异步3,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
}

执行结果如下,在主线程中任务按顺序执行,但并没有阻塞主线程:

主队列异步

我们通过上面六种组合,可以看到,同步不论串行还是并发,都没有开辟新线程,运行在主线程上,且都是顺序执行,所以并没有并发效果。异步不论串行还是并发,都开启了新线程(子线程),但是可见的是,多条异步串行,只开辟了一个子线程,多条异步并发,开启了多条子线程。主队列异步,并没有开启子线程,且为有序串行执行,但并没有阻塞主线程。

  • 5.4.7 GCD线程间的通讯
    开发中需要在主线程上进行UI的相关操作,通常会把一些耗时的操作放在其他线程,比如说图片文件下载等耗时操作。当完成了耗时操作之后,需要回到主线程进行UI的处理,这里就用到了线程之间的通讯。
- (IBAction)communicationBetweenThread:(id)sender {
    // 异步
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗时操作放在这里,例如下载图片。(运用线程休眠两秒来模拟耗时操作)
        [NSThread sleepForTimeInterval:2];
        NSString *picURLStr = @"https://123.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;
        });
    });
}
  • 5.4.8 GCD栅栏
    当任务需要异步进行,但是这些任务需要分成两组来执行,第一组完成之后才能进行第二组的操作。这时候就用了到GCD的栅栏方法dispatch_barrier_async和dispatch_barrier_sync详情可查阅官方文档。他们的不同之处在于:

dispatch_barrier_sync 将自己的任务插入到队列的时候,需要等待自己的任务结束之后才会继续插入被写在它后面的任务,然后执行它们。

dispatch_barrier_async 将自己的任务插入到队列之后,不会等待自己的任务结束,它会继续把后面的任务插入到队列,然后等待自己的任务结束后才执行后面任务。

实际上类似于同步异步,下面以dispatch_barrier_async为例:

- (void)barrierGCD {
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    // 异步执行
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"栅栏:并发异步1,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"栅栏:并发异步2,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_barrier_async(queue, ^{
        NSLog(@"------------barrier------------%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"栅栏:并发异步3,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"栅栏:并发异步4,%@",[NSThreadcurrentThread]);
        }
    });
}

执行结果如下,开启了多条线程,所有任务都是并发异步进行。但是第一组完成之后,才会进行第二组的操作

栅栏执行结果

需要注意的是:
dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block),栅栏函数中传入的参数队列必须是由 dispatch_queue_create 方法创建的队列,否则,与dispatch_async无异,起不到“栅栏”的作用了,对于dispatch_barrier_sync也是同理。

  • 5.4.9 GCD队列组
    平时在进行多线程处理任务时,有时候希望多个任务之间存在着一种联系,希望在所有的任务执行完后做一些总结性处理。那么就可以将多个任务放在一个任务组中进行统一管理。dispatch提供了相应的API供我们完成这一需求。

(1)dispatch_group_t相关属性介绍:

1.dispatch_group_async(group, queue, block);
将block任务添加到queue队列,并被group组管理

2.dispatch_group_enter(group);
声明dispatch_group_enter(group)下面的任务由group组管理,group组的任务数+1

3.dispatch_group_leave(group);
相应的任务执行完成,group组的任务数-1

4.dispatch_group_create();
创建一个group组

5.dispatch_group_wait(group1, DISPATCH_TIME_FOREVER);
当前线程暂停,等待dispatch_group_wait(group1, DISPATCH_TIME_FOREVER)上面的任务执行完成后,线程才继续执行。

6.dispatch_group_notify(group1, queue1,block);
监听group组中任务的完成状态,当所有的任务都执行完成后,触发block块,执行总结性处理。

(2)常见用法的区别
在使用group组处理任务时,常见的有两种组合。

其一:

dispatch_group_async(group, queue, block);

dispatch_group_notify(group1, queue1, block);

在这种组合下,根据任务是同步、异步又分为两种,这两种组合的执行代码与运行结果如下:

同步任务时:

- (void)groupSync{
    dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group1 = dispatch_group_create();
    dispatch_group_async(group1, queue1, ^{
        dispatch_sync(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                NSLog(@"同步任务1-:%ld",(long)i);
            }
        });
    });
    dispatch_group_async(group1, queue1, ^{
        dispatch_sync(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"同步任务2-:%ld",(long)i);
            }
        });
    });
    //等待上面的任务全部完成后,会收到通知执行block中的代码 (不会阻塞线程)
    dispatch_group_notify(group1, queue1, ^{
        NSLog(@"全部任务执行完成");
    });
}
group-同步

异步任务时:

- (void)groupAsync{
    dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group1 = dispatch_group_create();
    dispatch_group_async(group1, queue1, ^{
        dispatch_async(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"异步任务1,%ld",(long)i);
            }
        });
    });
    dispatch_group_async(group1, queue1, ^{
        dispatch_async(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"异步任务2,%ld",(long)i);
            }
        });
    });
    //等待上面的任务全部完成后,会收到通知执行block中的代码 (不会阻塞线程)
    dispatch_group_notify(group1, queue1, ^{
        NSLog(@"全部任务执行完成");
    });
}
group-异步

结论:dispatch_group_async(group, queue, block) 和 dispatch_group_notify(group1, queue1, block) 组合在执行同步任务时正常,在执行异步任务时不正常。

其二:

dispatch_group_enter(group);

dispatch_group_leave(group);

dispatch_group_notify(group1, queue1,block);

同样的在这种组合下,根据任务是同步、异步也分为两种,这两种组合的执行代码与运行结果如下:

同步任务时:

- (void)groupSyncEnter {
    dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group2 = dispatch_group_create();
    dispatch_group_enter(group2);
    dispatch_sync(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"同步任务1,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    dispatch_group_enter(group2);
    dispatch_sync(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"同步任务2,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    //等待上面的任务全部完成后,会收到通知执行block中的代码 (不会阻塞线程)
    dispatch_group_notify(group2, queue2, ^{
        NSLog(@"全部任务执行完成");
    });
}
group-同步

异步任务时:

- (void)groupAsyncEnter{
    dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group2 = dispatch_group_create();
    dispatch_group_enter(group2);
    dispatch_async(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"异步任务1,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    dispatch_group_enter(group2);
    dispatch_async(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"异步任务2,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    //等待上面的任务全部完成后,会收到通知执行block中的代码 (不会阻塞线程)
    dispatch_group_notify(group2, queue2, ^{
        NSLog(@"全部任务执行完成");
    });
}
group-异步

结论:dispatch_group_enter(group)、dispatch_group_leave(group) 和dispatch_group_notify(group, queue,block) 组合在执行同步任务时正常,在执行异步任务时正常。

  • 5.5 GCD一些常用API
    除了以上说道的api之外,还有一些常用CGD的api:
/**两个作用:
第一,变更队列的执行优先级;
第二,目标队列可以成为原队列的执行阶层。*/
dispatch_set_target_queue 

 /**想在指定时间后执行处理的情况,可使用dispatch_after函数来实现。
需要注意的是,dispatch_after函数并不是在指定时间后执行处理,
而只是在指定时间追加处理到Dispatch Queue。*/
dispatch_after

dispatch_apply//第一个参数为重复次数,第二个参数为追加对象的Dispatch,第三个参数为追加的处理
dispatch_apply(10, queue, ^(size_t index) {
    NSLog(@"%zu",index);
});

dispatch_suspend(queue)//函数挂起指定的Dispatch Queue

dispatch_resume(queue)//函数恢复指定的Dispatch Queue
 
dispatch_once//函数是保证在应用程序执行中只执行一次指定处理的API
  • 5.6 GCD终止线程
    如果还未执行的子线程可以用dispatch_block_cancel来取消(需要注意必须用dispatch_block_create创建dispatch_block_t)
- (void)stopSync{
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    dispatch_block_t block1 = dispatch_block_create(0, ^{
        NSLog(@"block1 begin");
        [NSThread sleepForTimeInterval:3];
        NSLog(@"block1 end");
    });

    dispatch_block_t block2 = dispatch_block_create(0, ^{
        NSLog(@"block2 ");
    });
    dispatch_async(queue, block1);
    dispatch_async(queue, block2);
    //取消执行block2
    dispatch_block_cancel(block2);
}

运行结果如下:

image

但是,如果执行中的线程,我们该怎么让其退出呢?方法如下:

- (void)stopAsync {
    __block BOOL isFinish =NO;
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        for(long i=0; i<10000; i++) {
            NSLog(@"正在执行第 %ld 次",i);
            sleep(1);
            if(isFinish ==YES) {
                NSLog(@"已经终止了");
                return;
            }
        };
    });
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW,(int64_t)(10 * NSEC_PER_SEC)),dispatch_get_main_queue(), ^{
        NSLog(@"我要停止啦");
        isFinish =YES;
    });
}

执行结果:

image

方法很简单,线程外设置__block变量,配合线程中return结束。


六、NSOperation的理解与使用

6.1 NSOperation, NSOperationQueue 简介

NSOperation需要配合NSOperationQueue来实现多线程;NSOperation,NSOperationQueue 是苹果提供给我们的一套多线程解决方案,是基于 GCD 更高一层的封装,完全面向对象。但是比 GCD 更简单易用,代码可读性更高。

既然是基于 GCD 的更高一层的封装。那么,GCD 的一些概念同样适用于 NSOperation,NSOperationQueue。在 NSOperation,NSOperationQueue 中也有类似于任务(操作)和队列(操作队列)的概念。

  • 操作(Operation)
    • 执行操作的意思,即在线程中执行的那段代码。在 GCD 中是放在 block 中的。在 NSOperation 中,我们使用 NSOperation 子类NSInvocationOperation,NSBlockOperation,或者时自定义子类来封装操作。
  • 操作队列(Operation Queue)
    • 这里的队列指操作队列,即用来存放操作的队列。不同于 GCD中的调度队列 FIFO(先进先出)的原则。NSOperationQueue 对于添加到队列中的操作,首先进入准备就绪的状态(就绪状态取决于操作之间的依赖关系),然后进入就绪状态的操作的开始执行顺序(非结束执行顺序),由操作之间相对的优先级决定(优先级是操作对象自身的属性);
    • 操作队列通过设置最大并发操作数(maxConcurrentOperationCount)来控制并发,串行;
    • NSOperationQueue 为我们提供了两种不同类型的队列:主队列和自定义队列。主队列运行在主线程之上,而自定义队列在后台执行。

NSOperation实现多线程的步骤如下:

  1. 创建操作:先将要执行的操作封装到一个 NSOperation 对象中
  2. 创建队列:创建 NSOperationQueue 对象。
  3. 将操作加入到队列中:将 NSOpeartion 对象添加到 NSOperationQueue 对象中。

需要注意的是,NSOperation是个抽象类,实际运用时中需要使用它的子类,有三种方式:

  1. 使用子类NSInvocationOperation
  2. 使用子类NSBlockOperation
  3. 定义继承自NSOperation的子类,通过实现内部相应的方法来封装任务。
6.2 NSOperation的三种创建方式
6.2.1 使用NSInvocationOperation创建
//NSInvocationOperation使用
- (void)useNSInvocationOperation{
    //创建NSInvocationOperation并关联方法
    NSInvocationOperation* opratin = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAction) object:nil];
    //执行操作
    [opratin start];
}
- (void)invocationOperationAction{
    NSLog(@"NSInvocationOperation任务,没有加入队列==%@", [NSThread currentThread]);
}

执行结果如下,得到结论:程序在主线程执行,没有开启新线程。这是因为 NSOperation 多线程的使用需要配合队列 NSOperationQueue ,在不使用 NSOperationQueue ,单独使用 NSOperation 的情况下,系统同步执行操作。

执行结果

6.2.2 使用NSBlockOperation创建
//NSBlockOperation使用
- (void)useNSBlockOperation{
    //创建NSBlockOperation并把任务放到block中
    NSBlockOperation* operation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"NSInvocationOperation任务,没有加入队列==%@", [NSThread currentThread]);
    }];
    //执行操作
    [operation start];
}

执行结果如下,结论上同,不在阐述。


执行结果

但是NSBlockOperation有一个方法addExecutionBlock:,通过这个方法可以让NSBlockOperation实现多线程。代码如下:

//NSBlockOperation使用
- (void)useNSBlockOperation{
    //创建NSBlockOperation并把任务放到block中
    NSBlockOperation* operation = [NSBlockOperation blockOperationWithBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"NSInvocationOperation任务==%@", [NSThread currentThread]);
        }
//        NSLog(@"NSInvocationOperation任务,没有加入队列==%@", [NSThread currentThread]);
    }];
    [operation addExecutionBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"addExecutionBlock方法添加任务1==%@", [NSThread currentThread]);
        }
    }];
    [operation addExecutionBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"addExecutionBlock方法添加任务2==%@", [NSThread currentThread]);
        }
    }];
    [operation addExecutionBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"addExecutionBlock方法添加任务3==%@", [NSThread currentThread]);
        }
    }];
    //执行操作
    [operation start];
}

执行结果如下,(第二个执行结果是添加了十个操作,执行了两次出现的结果...)


执行结果1

执行结果2

得到结论:

  • 通过addExecutionBlock可以为 NSBlockOperation 添加额外的操作。这些操作(包括blockOperationWithBlock中的操作)可以再不同的线程中同时(并发)执行。只有当所有相关的操作已经执行完成时,才视为完成。
  • 如果添加的操作多的话,blockOperationWithBlock:中的操作也可能会在其他线程(非当前线程)中执行,这是由系统决定的,并不是说添加到blockOperationWithBlock:中的操作一定会在当前线程中执行。(第二张执行结果,好奇的可以试试,嘿嘿...)
  • NSBlockOperation是否会开启新线程,取决于操作的个数。如果添加的操作的个数多,就会开启新线程。开启的线程数是由系统来决定的。
6.2.3 使用继承自NSOperation的子类创建

首先我们定义一个继承自NSOperation的类,然后重写它的main方法,之后就可以使用这个子类来进行相关的操作了。

/*******************"OurNSOperation.h"*************************/
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface OurNSOperation : NSOperation
@end
NS_ASSUME_NONNULL_END

/*******************"OurNSOperation.m"*************************/
#import "OurNSOperation.h"
@implementation OurNSOperation
- (void)main{
    for(int i = 0; i < 3; i++){
        NSLog(@"NSOperation的子类OurNSOperation==%@",[NSThread currentThread]);
    }
}
@end
/*******"回到主控制器导入头文件并使用OurNSOperation"********/
- (void)useOurNSOperation{
    //创建OurNSOperation对象
    OurNSOperation* operation = [[OurNSOperation alloc] init];
    //开始执行
    [operation start];
}

运行结果如下,依然是在主线程执行。所以,NSOperation是需要配合队列NSOperationQueue来实现多线程的。


执行结果
6.3 队列NSOperationQueue

NSOperationQueue只有两种队列:主队列、自定义队列。自定义队列包含了串行和并发。

  • 主队列的创建如下:主队列上的任务是在主线程执行的。
    NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];

  • 自定义队列(非主队列)的创建如下:加入到自定义队列中的任务,默认就是并发,开启多线程。
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

  • 需要注意的是:

    • 非主队列(自定义队列)可以实现串行或并行。
    • 队列NSOperationQueue有一个参数叫做最大并发数:maxConcurrentOperationCount。
    • maxConcurrentOperationCount默认为-1,直接并发执行,所以加入到‘非主队列’中的任务默认就是并发,开启多线程。
    • 当maxConcurrentOperationCount为1时,则表示不开线程,也就是串行。
    • 当maxConcurrentOperationCount大于1时,进行并发执行。
    • 系统对最大并发数有一个限制,所以即使程序员把maxConcurrentOperationCount设置的很大,系统也会自动调整。所以把最大并发数设置的很大是没有意义的。
6.4 NSOperation + NSOperationQueue

NSOperation 需要配合 NSOperationQueue 来实现多线程,所以把任务加入队列,这才是NSOperation的常规使用方式。

6.4.1 addOperation添加任务到队列

先创建好任务,然后运用addOperation:<#(nonnull NSOperation *)#>方法来吧任务添加到队列中,示例代码如下:

- (void)useAddOperation {
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    NSInvocationOperation* operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationActions) object:nil];
    NSBlockOperation* blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"NSBlockOperation任务 == %@ 第%d次执行",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperation:operation];
    [queue addOperation:blockOperation];
}

- (void)invocationOperationActions {
    for (int i = 0; i < 3; i++){
        NSLog(@"NSInvocationOperation任务 == %@ 第%d次执行",[NSThread currentThread],i);
    }
}

运行结果如下,可以看出,任务都是并发在子线程执行的,开启了新线程。


执行结果
6.4.2 addOperationWithBlock添加任务到队列

这是一个更方便的把任务添加到队列的方法,直接把任务写在block中,添加到任务中。

- (void)useAddOperationWithBlock{
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++){
            NSLog(@"任务1 == %@ 第%d次执行",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++){
            NSLog(@"任务2 == %@ 第%d次执行",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++){
            NSLog(@"任务3 == %@ 第%d次执行",[NSThread currentThread],i);
        }
    }];
}

执行结果如下,使用 addOperationWithBlock:将操作加入到操作队列后能够开启新线程,进行并发执行。


执行结果
6.4.3 maxConcurrentOperationCount控制串行执行、并发执行

maxConcurrentOperationCount,叫做最大并发操作数,用来控制一个特定队列中可以有多少个操作同时参与并发执行。

注意:这里maxConcurrentOperationCount控制的不是并发线程的数量,而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行。(6.3中做过一些介绍,不再阐述)

- (void)useMaxConcurrentOperationCount{
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    
    //设置并发数
    queue.maxConcurrentOperationCount = 1;//串行队列
//    queue.maxConcurrentOperationCount = 4;//并行队列
//    queue.maxConcurrentOperationCount = 100;//并行队列
    
    // 使用 addOperationWithBlock添加操作到队列中
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务1 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务2 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务3 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务4 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务5 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务6 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
}
  • 最大并发操作数为1时


    最大并发操作数为1时
  • 最大并发操作数为4时


    最大并发操作数为4时
  • 最大并发操作数为100时


    最大并发操作数为100时
  • 可以看出:当最大并发操作数为1时,操作是按照顺序串行执行的,并且一个操作完成之后,下一个操作才开始执行。当最大操作并发数大于1时,操作是并发执行的,可以同时执行多个操作。而且开启线程数量是由系统决定的,不需要我们来管理。

6.5 NSOperation的操作依赖

NSOperation有一个非常好用的方法,就是操作依赖。可以从字面意思理解:某一个操作(operation2)依赖于另一个操作(operation1),只有当operation1执行完毕,才能执行operation2,这时,就是操作依赖大显身手的时候了。NSOperation 提供了3个接口供我们管理和查看依赖。

  • - (void)addDependency:(NSOperation *)op;添加依赖,使当前操作依赖于操作 op 的完成
  • - (void)removeDependency:(NSOperation *)op;移除依赖,取消当前操作对象操作 op 的依赖
  • @property (readonly, copy) NSArray<NSOperation *> *dependencies;在当前操作开始执行之前完成执行的所有 NSOperation 对象数组。

代码示例:A 执行完操作,B 才能执行操作。

- (void)useAddDependency{
    // 创建队列
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    
    queue.maxConcurrentOperationCount = 4;//并行队列
    
    // 创建操作
    NSBlockOperation* A = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务A == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    NSBlockOperation* B = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务B == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    // 添加依赖
    [B addDependency:A];    // 让B依赖于A,则先执行A,再执行B.
    
    // 添加操作到队列中
    [queue addOperation:A];
    [queue addOperation:B];
}

执行结果:

执行结果

按照6.4.3所述,我们设置了queue.maxConcurrentOperationCount = 4 ;本应并行执行,但是设置依赖后,B等A执行完毕后才执行的。

6.6 NSOperation 优先级

NSOperation 提供了queuePriority(优先级)属性,queuePriority 属性适用于同一操作队列中的操作,不适用于不同操作队列中的操作。默认情况下,所有新创建的操作对象优先级都是NSOperationQueuePriorityNormal。但是我们可以通过setQueuePriority:方法来改变当前操作在同一队列中的执行优先级。

// 优先级的取值
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0,
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
};

对于添加到队列中的操作,首先进入准备就绪的状态(就绪状态取决于操作之间的依赖关系),然后进入就绪状态的操作的开始执行顺序(非结束执行顺序)由操作之间相对的优先级决定(优先级是操作对象自身的属性)。

  • queuePriority 属性决定了进入准备就绪状态下的操作之间的开始执行顺序。并且,优先级不能取代依赖关系。
  • 如果一个队列中既包含高优先级操作,又包含低优先级操作,并且两个操作都已经准备就绪,那么队列先执行高优先级操作。
  • 如果,一个队列中既包含了准备就绪状态的操作,又包含了未准备就绪的操作,未准备就绪的操作优先级比准备就绪的操作优先级高。那么,虽然准备就绪的操作优先级低,也会优先执行。优先级不能取代依赖关系。如果要控制操作间的启动顺序,则必须使用依赖关系。
6.7 NSOperation,NSOperationQueue 线程间的通信

在 iOS 开发过程中,我们一般在主线程里边进行 UI 刷新,例如:点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程,比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时,需要回到主线程,那么就用到了线程之间的通讯。

//线程间通信
- (void)useMainQueue {
    // 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 添加操作
    [queue addOperationWithBlock:^{
        // 异步执行耗时操作
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务1 == %@ 第%d次执行",[NSThread currentThread],i);
        }
        
        // 回到主线程
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            for (int i = 0; i < 2; i++) {
                [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
                NSLog(@"任务2 == %@ 第%d次执行",[NSThread currentThread],i);
            }
        }];
    }];
}

执行结果:


执行结果

可以看出:通过线程间的通信,先在其他线程中执行操作,等操作执行完了之后再回到主线程执行主线程的相应操作。

6.8 NSOperation、NSOperationQueue 常用属性和方法归纳
6.8.1 NSOperation 常用属性和方法
  • 取消操作方法
    • - (void)cancel;可取消操作,实质是标记 isCancelled 状态。
  • 判断操作状态方法
    • - (BOOL)isFinished;判断操作是否已经结束。
    • - (BOOL)isCancelled; 判断操作是否已经标记为取消。
    • - (BOOL)isExecuting;判断操作是否正在在运行。
    • - (BOOL)isReady;判断操作是否处于准备就绪状态,这个值和操作的依赖关系相关。
  • 操作同步
    • - (void)waitUntilFinished; 阻塞当前线程,直到该操作结束。可用于线程执行顺序的同步。
    • - (void)setCompletionBlock:(void (^)(void))block;completionBlock 会在当前操作执行完毕时执行 completionBlock。
    • - (void)addDependency:(NSOperation *)op; 添加依赖,使当前操作依赖于操作 op 的完成。
    • - (void)removeDependency:(NSOperation *)op; 移除依赖,取消当前操作对操作 op 的依赖。
    • @property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。
6.8.2 NSOperationQueue 常用属性和方法
  • 取消/暂停/恢复操作
    • - (void)cancelAllOperations;可以取消队列的所有操作。
    • - (BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态,NO 为恢复状态。
    • - (void)setSuspended:(BOOL)b; 可设置操作的暂停和恢复,YES 代表暂停队列,NO 代表恢复队列。
  • 操作同步
    • - (void)waitUntilAllOperationsAreFinished; 阻塞当前线程,直到队列中的操作全部执行完毕。
  • 添加/获取操作
    • - (void)addOperationWithBlock:(void (^)(void))block;向队列中添加一个 NSBlockOperation 类型操作对象。
    • - (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向队列中添加操作数组,wait 标志是否阻塞当前线程直到所有操作结束
    • - (NSArray *)operations; 当前在队列中的操作数组(某个操作执行结束后会自动从这个数组清除)。
    • - (NSUInteger)operationCount; 当前队列中的操作数。
  • 获取队列
    • + (id)currentQueue; 获取当前队列,如果当前线程不是在 NSOperationQueue 上运行则返回 nil。

    • + (id)mainQueue;获取主队列。

注意
这里的暂停和取消(包括操作的取消和队列的取消)并不代表可以将当前的操作立即取消,而是当当前的操作执行完毕之后不再执行新的操作。
暂停和取消的区别在于:暂停操作之后还可以恢复操作,继续向下执行;而取消操作之后,所有的操作都清空了,无法再接着执行剩下的操作。


总结:
借鉴很多内容,但是有些忘了是谁的,就不一一列举了。文章有点长,希望大家能耐心的看下来,如果发现问题,也希望大家积极指正,如有不足,也恳请大家告知,谢谢。


参考资料


参考文章
iOS多线程全套:线程生命周期,多线程的四种解决方案,线程安全问题,GCD的使用,NSOperation的使用
iOS 多线程: [NSOperation NSOperationQueue] 详解