iOS开发多线程-NSOperation，NSOperation

1.简介

NSOperation、NSOperationQueue是基于GCD的封装，完全面向对象。比GCD更为简单，代码可读性也高了不少。
NSOperation和NSOperationQueue有不少有点，如下

• 可以添加完成代码，在操作完成后执行
• 可以添加操作之间的顺序
• 设定操作之间的优先级
• 可以方便的取消操作
• 可以观察操作执行状态:isCancelled, isAsynchronous, isExecuting, isFinished, isReady等等

既然是基于GCD封装的，那么有些概念还是可以套用一下的。比如操作对应任务，
队列对应操作队列

• 操作

  • 执行操作就是在线程中执行代码
  • 使用NSOperation的子类NSInvocationOperation,NSBlockOperation,或者自定义子类来封装操作

• 操作队列

  • 操作队列就是存放操作的队列，但是和GCD的队列不一样，不遵循FIFO原则。首先通过依赖关系（dependencies）进入准备就绪状态（ready）。依赖关系是绝对的，哪怕是多线程情况下，也会等待之前的依赖线程执行完才能执行当前操作。
  • 操作队列通过设置最大并发操作数（maxConcurrentOperationCount）来控制并发，串行
  • NSOperationQueue提供了两种类型的队列，一种是主队列和自定义队列。主队列运行在主线程上，自定义队列在后台执行。

2.使用步骤

NSOperation操作步骤

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

2.1 创建操作

NSOperation是一个抽象类，需要我们使用它的子类。有以下三种选择：

1. NSInvocationOperation
2. NSBlockOperation
3. 自定义继承自NSOperation的子类，实现相应方法来封装操作

2.1.1 NSInvocationOperation

- (void)invocation{
    NSInvocationOperation *op = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(task) object:nil];
    [op start];
}

- (void)task1{
    for (int i = 0; i < 2; i++) {
        [NSThread sleepForTimeInterval:2];
        NSLog(@"1---%@", [NSThread currentThread]);
    }
}

2018-05-17 14:17:02.903373+0800 MultiThread[13966:1261901] 1---<NSThread: 0x604000074f80>{number = 1, name = main}
2018-05-17 14:17:04.905077+0800 MultiThread[13966:1261901] 1---<NSThread: 0x604000074f80>{number = 1, name = main}

    [NSThread detachNewThreadSelector:@selector(invocation) toTarget:self withObject:nil];

2018-05-17 14:17:44.535875+0800 MultiThread[13991:1263666] 1---<NSThread: 0x60000046de80>{number = 3, name = (null)}
2018-05-17 14:17:46.541399+0800 MultiThread[13991:1263666] 1---<NSThread: 0x60000046de80>{number = 3, name = (null)}

不使用NSOperationQueue，会直接在主线程中执行操作，不会创建新线程。如果在其他线程中执行，就会打印其他线程

2.1.2 NSBlockOperation

- (void)block{
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op start];
}

2018-05-17 14:20:32.340855+0800 MultiThread[14056:1269157] 1---<NSThread: 0x60400006f140>{number = 1, name = main}
2018-05-17 14:20:34.342273+0800 MultiThread[14056:1269157] 1---<NSThread: 0x60400006f140>{number = 1, name = main}

NSBlockOperation提供了一个方法addExecutionBlock，通过这个方法，就能为NSBlockOperation添加额外的操作，只有在blockOperationWithBlock和addExecutionBlock中的操作全部完成后，才算完成。如果添加的操作过多，系统有可能会开启新的线程来完成操作。

- (void)block{
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"5---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"6---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    
    [op start];
}

- (void)invocation{
    NSInvocationOperation *op = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(task1) object:nil];
    [op start];
}

2018-05-17 14:28:06.052693+0800 MultiThread[14158:1281194] 1---<NSThread: 0x60400007ff40>{number = 1, name = main}
2018-05-17 14:28:06.052693+0800 MultiThread[14158:1281347] 3---<NSThread: 0x600000467600>{number = 3, name = (null)}
2018-05-17 14:28:06.052698+0800 MultiThread[14158:1281349] 2---<NSThread: 0x6040004727c0>{number = 4, name = (null)}
2018-05-17 14:28:06.052795+0800 MultiThread[14158:1281348] 4---<NSThread: 0x600000467500>{number = 5, name = (null)}
2018-05-17 14:28:08.054454+0800 MultiThread[14158:1281194] 1---<NSThread: 0x60400007ff40>{number = 1, name = main}
2018-05-17 14:28:08.054454+0800 MultiThread[14158:1281347] 3---<NSThread: 0x600000467600>{number = 3, name = (null)}
2018-05-17 14:28:08.054454+0800 MultiThread[14158:1281349] 2---<NSThread: 0x6040004727c0>{number = 4, name = (null)}
2018-05-17 14:28:08.054525+0800 MultiThread[14158:1281348] 4---<NSThread: 0x600000467500>{number = 5, name = (null)}
2018-05-17 14:28:10.055459+0800 MultiThread[14158:1281194] 6---<NSThread: 0x60400007ff40>{number = 1, name = main}
2018-05-17 14:28:10.055531+0800 MultiThread[14158:1281347] 5---<NSThread: 0x600000467600>{number = 3, name = (null)}
2018-05-17 14:28:12.056989+0800 MultiThread[14158:1281194] 6---<NSThread: 0x60400007ff40>{number = 1, name = main}
2018-05-17 14:28:12.056989+0800 MultiThread[14158:1281347] 5---<NSThread: 0x600000467600>{number = 3, name = (null)}

打印结果可以看出：AddExecutionBlock和blockOperationWithBlock两者是在不同的线程中执行的。所以如果任务过多，是有可能会开启新线程的。另外，blockOperationWithBlock的操作有可能还在开启的新线程执行。

2.1.3 使用自定义的NSOperation子类

当系统提供的两个子类不能满足我们的要求时，我们可以通过自定义继承自NSOperation的子类。重写main和start方法来定义自己的NSOperation对象。

//CusOperation.h
#import <Foundation/Foundation.h>

@interface CusOperation : NSOperation

@end

//CusOperation.m
#import "CusOperation.h"

@implementation CusOperation

- (void)main{
    if (!self.isCancelled) {
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];
            NSLog(@"1---%@", [NSThread currentThread]);
        }
    }
}

@end

- (void)customOperation{
    CusOperation *op = [[CusOperation alloc]init];
    [op start];
}

2018-05-17 14:38:16.129219+0800 MultiThread[14331:1299438] 1---<NSThread: 0x600000079340>{number = 1, name = main}
2018-05-17 14:38:18.129706+0800 MultiThread[14331:1299438] 1---<NSThread: 0x600000079340>{number = 1, name = main}

以上示例可以看出：

在没有使用 NSOperationQueue、在主线程单独使用自定义继承自 NSOperation 的子类的情况下，是在主线程执行操作，并没有开启新线程

2.2 创建队列

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

• 主队列
  • 添加到主队列的操作，都会方法哦主线程中执行。

NSOperationQueue *queue = [NSOperationQueue mainQueue];

• 自定义队列
  • 添加到该队列的操作，会自动放到子线程中执行
  • 同时包含了串行，并发功能

// 自定义队列创建方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];

2.3 将操作添加到队列中

将操作添加到操作队列中区，有两种方法：

1. - (void)addOperation:(NSOperation *)op;
   先创建操作，再讲创建好的操作添加到创建好的队列中去

- (void)addOperationToQueue{
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(task1) object:nil];
    NSInvocationOperation *op2 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(task2) object:nil];
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    
    [op3 addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"Finished --- %@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];

}

2. - (void)addOperationWithBlock:(void (^)(void))block;
   不需要创建操作，在block中直接添加操作，直接将包含操作的block添加到队列中。

- (void)addOperationByBlock{
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 2.使用 addOperationWithBlock: 添加操作到队列中
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
}

2018-05-17 15:09:17.220840+0800 MultiThread[14694:1339685] 1---<NSThread: 0x60400027ce40>{number = 3, name = (null)}
2018-05-17 15:09:17.220840+0800 MultiThread[14694:1338535] 3---<NSThread: 0x6000006652c0>{number = 4, name = (null)}
2018-05-17 15:09:17.220870+0800 MultiThread[14694:1339697] 2---<NSThread: 0x60400027e040>{number = 5, name = (null)}
2018-05-17 15:09:19.223380+0800 MultiThread[14694:1339685] 1---<NSThread: 0x60400027ce40>{number = 3, name = (null)}
2018-05-17 15:09:19.223399+0800 MultiThread[14694:1338535] 3---<NSThread: 0x6000006652c0>{number = 4, name = (null)}
2018-05-17 15:09:19.223464+0800 MultiThread[14694:1339697] 2---<NSThread: 0x60400027e040>{number = 5, name = (null)}

可以看出开启了新线程，并发执行。

3. NSOperationQueue控制串行，并行

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

• maxConcurrentOperationCount默认-1，表示不做限制，可以进行并发操作
• maxConcurrentOperationCount等于1，队列为串行队列，只能串行执行
• maxConcurrentOperationCount大于1时，队列为并发队列，可以进行并发执行

- (void)setMaxConcurrentOperationCount{
    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 2.设置最大并发操作数
    queue.maxConcurrentOperationCount = 1; // 串行队列
    // queue.maxConcurrentOperationCount = 2; // 并发队列
    // queue.maxConcurrentOperationCount = 6; // 并发队列
    
    // 3.添加操作
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
}

设置maxConcurrentOperationCount等于1的时候。

2018-05-17 15:14:48.876623+0800 MultiThread[14777:1347945] 1---<NSThread: 0x600000461d40>{number = 3, name = (null)}
2018-05-17 15:14:50.879393+0800 MultiThread[14777:1347945] 1---<NSThread: 0x600000461d40>{number = 3, name = (null)}
2018-05-17 15:14:52.884111+0800 MultiThread[14777:1347942] 2---<NSThread: 0x60400007a980>{number = 4, name = (null)}
2018-05-17 15:14:54.888856+0800 MultiThread[14777:1347942] 2---<NSThread: 0x60400007a980>{number = 4, name = (null)}
2018-05-17 15:14:56.893411+0800 MultiThread[14777:1347945] 3---<NSThread: 0x600000461d40>{number = 3, name = (null)}
2018-05-17 15:14:58.895721+0800 MultiThread[14777:1347945] 3---<NSThread: 0x600000461d40>{number = 3, name = (null)}

设置maxConcurrentOperationCount等于2的时候。

2018-05-17 15:16:59.695592+0800 MultiThread[14819:1352085] 2---<NSThread: 0x600000663f40>{number = 3, name = (null)}
2018-05-17 15:16:59.695593+0800 MultiThread[14819:1352087] 1---<NSThread: 0x604000270f80>{number = 4, name = (null)}
2018-05-17 15:17:01.701006+0800 MultiThread[14819:1352087] 1---<NSThread: 0x604000270f80>{number = 4, name = (null)}
2018-05-17 15:17:01.701010+0800 MultiThread[14819:1352085] 2---<NSThread: 0x600000663f40>{number = 3, name = (null)}
2018-05-17 15:17:03.706541+0800 MultiThread[14819:1352088] 3---<NSThread: 0x60400027a640>{number = 5, name = (null)}
2018-05-17 15:17:05.711808+0800 MultiThread[14819:1352088] 3---<NSThread: 0x60400027a640>{number = 5, name = (null)}

设置maxConcurrentOperationCount等于6的时候。

2018-05-17 15:17:46.013273+0800 MultiThread[14843:1353840] 2---<NSThread: 0x600000462a00>{number = 5, name = (null)}
2018-05-17 15:17:46.013280+0800 MultiThread[14843:1353842] 1---<NSThread: 0x604000461780>{number = 4, name = (null)}
2018-05-17 15:17:46.013280+0800 MultiThread[14843:1353841] 3---<NSThread: 0x600000461c80>{number = 3, name = (null)}
2018-05-17 15:17:48.016936+0800 MultiThread[14843:1353842] 1---<NSThread: 0x604000461780>{number = 4, name = (null)}
2018-05-17 15:17:48.016936+0800 MultiThread[14843:1353840] 2---<NSThread: 0x600000462a00>{number = 5, name = (null)}
2018-05-17 15:17:48.016982+0800 MultiThread[14843:1353841] 3---<NSThread: 0x600000461c80>{number = 3, name = (null)}

4. NSOperation操作依赖

通过操作依赖，我们可以很轻松的控制操作执行顺序，有以下三个方法属性，帮助我们管理依赖关系。

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

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

2018-05-17 15:28:00.975331+0800 MultiThread[14961:1367884] 1---<NSThread: 0x60000027cac0>{number = 3, name = (null)}
2018-05-17 15:28:02.980260+0800 MultiThread[14961:1367884] 1---<NSThread: 0x60000027cac0>{number = 3, name = (null)}
2018-05-17 15:28:04.984993+0800 MultiThread[14961:1367885] 2---<NSThread: 0x60400027ccc0>{number = 4, name = (null)}
2018-05-17 15:28:06.990673+0800 MultiThread[14961:1367885] 2---<NSThread: 0x60400027ccc0>{number = 4, name = (null)}

添加依赖后，永远是op1先执行。

5. NSOperation优先级

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

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

在没有依赖关系的操作之间，可以通过优先级来决定操作开始执行的顺序。

6. NSOperation，NSOperationQueue线程间的通信

- (void)communication{
    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    
    // 2.添加操作
    [queue addOperationWithBlock:^{
        // 异步进行耗时操作
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
        
        // 回到主线程
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            // 进行一些 UI 刷新等操作
            for (int i = 0; i < 2; i++) {
                [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
                NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
            }
        }];
    }];
}

2018-05-17 15:37:56.670333+0800 MultiThread[15086:1383288] 1---<NSThread: 0x604000470f40>{number = 3, name = (null)}
2018-05-17 15:37:58.672749+0800 MultiThread[15086:1383288] 1---<NSThread: 0x604000470f40>{number = 3, name = (null)}
2018-05-17 15:38:00.674389+0800 MultiThread[15086:1382902] 2---<NSThread: 0x60000006f000>{number = 1, name = main}
2018-05-17 15:38:02.675024+0800 MultiThread[15086:1382902] 2---<NSThread: 0x60000006f000>{number = 1, name = main}

线程中的通信，是先执行其他子线程的操作，然后回到主线程执行相关操作。

7.线程安全

线程同步安全问题，可以通过NSLock来实现，以之前GCD中有关smemaphore的卖票代码为例子，只需要在卖票操作之前加上[self.lock lock];在操作完成后解锁[self.lock unlock];即可。

- (void)saleTicketSafe {
    while (1) {

        // 加锁
        [self.lock lock];

        if (self.ticketSurplusCount > 0) {
            //如果还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        }

        // 解锁
        [self.lock unlock];

        if (self.ticketSurplusCount <= 0) {
            NSLog(@"所有火车票均已售完");
            break;
        }
    }
}

8. 其他属性，方法

8.1 NSOperation属性和方法

1.取消操作方法

- (void)cancel; 可取消操作，实质是标记 isCancelled 状态。

2.判断操作状态方法

- (BOOL)isFinished; 判断操作是否已经结束。
- (BOOL)isCancelled; 判断操作是否已经标记为取消。
- (BOOL)isExecuting; 判断操作是否正在在运行。
- (BOOL)isReady; 判断操作是否处于准备就绪状态，这个值和操作的依赖关系相关。

3.操作同步

- (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; 在当前操作开始执行之前完成执行的所有操作对象数组。

8.2 NSOperationQueue属性和方法

1.取消/暂停/恢复操作

- (void)cancelAllOperations; 可以取消队列的所有操作。
- (BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。
- (void)setSuspended:(BOOL)b; 可设置操作的暂停和恢复，YES 代表暂停队列，NO 代表恢复队列。

2.操作同步

- (void)waitUntilAllOperationsAreFinished; 阻塞当前线程，直到队列中的操作全部执行完毕。

3.添加/获取操作

- (void)addOperationWithBlock:(void (^)(void))block; 向队列中添加一个 NSBlockOperation 类型操作对象。
- (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束
- (NSArray *)operations; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）。
- (NSUInteger)operationCount; 当前队列中的操作数。

4.获取队列

+ (id)currentQueue; 获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。
+ (id)mainQueue; 获取主队列。

参考
iOS多线程：『NSOperation、NSOperationQueue』详尽总结
并发编程指南
NSOperation
并发编程：API 及挑战