iOS之多线程：线程的生命周期，NSThread、GCD、NSO

前言：

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

正文：

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

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：

/**在必须将不可并行执行的处理追加到多个Serial Dispatch Queue中时，
如果使用dispatch_set_target_queue函数将目标指定为某一个Serial Dispatch Queue，
即可防止处理并行执行。*/
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;获取主队列。

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

---

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

---

参考资料

• 苹果官方——并发编程指南：Operation Queues
• 苹果官方文档：NSOperation

---

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