iOS多线程之NSOperation

简介

Objective-C 对 GCD 的 API 进行了面向对象的封装，GCD 中的任务对应 NSOpertion 对象，GCD 中的队列则对应 NSOpertionQueue 对象。NSOpertion 和 NSOpertionQueue 还提供判断执行状态、取消任务、控制线程数量等更多任务管理的 API。所以 AFNetworking 与 SDWebImage 等管理大量独立任务的第三方都主要使用 NSOperation 实现多线程。

NSOperation 对“任务”进行了抽象。作为抽象基类，它为子类提供了十分有用且线程安全的方式来建立状态、优先级、依赖等模型。系统提了 NSBlockOperation 和 NSInvocationOperation 两个分别以 Block 和 Invocation 储存任务的具体实现。你也可以自己继承 NSOperation 实现自己特有的储存/执行任务的方式。

NSOperation 中的任务只能执行一次。将 NSOperation 添加到 NSOperationQueue 中后就会在子线程自动执行（直接执行或使用 GCD 间接执行）。如果你不想使用 NSOperationQueue，也可以手动调用 NSOperation 的 start 方法来执行它。调用 start 方法默认会在当前线程执行，而且你必须保证在 NSOperation 的 ready 状态下调用，否则将会抛出异常。如果想让 NSOperation 在子线程执行，需要我们手动将其放在子线程，我们也可以子类化 NSOperation 并重写 main 方法实现这个过程。这显然给我们带了很多的麻烦，所以除非特别需要，最好都使用 NSOperationQueue 来执行 NSOperation。

NSOperation

NSOperation 是一个抽象类，我们应该使用具体的子类 NSBlockOperation 或 NSInvocationOperation 来创建 Operation。

NSOperation的属性和方法

@interface NSOperation : NSObject {

// 开始执行任务，默认实现会调用 main 方法、修改状态等。
- (void)start;

// 默认实现为空，子类实现它来执行任务。
- (void)main;

// 判断任务是否取消
@property (readonly, getter=isCancelled) BOOL cancelled;
// 取消任务
- (void)cancel;

// 判断任务是否正在执行
@property (readonly, getter=isExecuting) BOOL executing;
// 判断任务是否执行完成
@property (readonly, getter=isFinished) BOOL finished;
// 是否异步执行，默认为 NO，已经被废弃
@property (readonly, getter=isConcurrent) BOOL concurrent;
// 是否同步执行，默认为 NO
@property (readonly, getter=isAsynchronous) BOOL asynchronous;
// 任务是否可以被执行
@property (readonly, getter=isReady) BOOL ready;

// 添加依赖 operation，使当前 operation 在依赖 operation 执行完成后开始
- (void)addDependency:(NSOperation *)op;
// 移除依赖 operation
- (void)removeDependency:(NSOperation *)op;

// 获取所有依赖的 operation
@property (readonly, copy) NSArray *dependencies;

// 在 operation queue 中的优先级，默认为 normal
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0,
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
};
@property NSOperationQueuePriority queuePriority;

// 在 operation 的 main task 完成时执行
@property (nullable, copy) void (^completionBlock)(void);

// 同步执行，阻塞当前线程直到任务完成
- (void)waitUntilFinished;

// 线程优先级，范围 0-1，默认 0.5，已经被废弃，使用 qualityOfService
@property double threadPriority;

// queuePriority 决定了任务执行的顺序
// qualityOfService 则决定了任务开始执后系统资源分配的优先级，例如 CPU 时间片, 网络资源, 硬盘资源等，默认 NSQualityOfServiceBackground
@property NSQualityOfService qualityOfService;

// 任务名称
@property (nullable, copy) NSString *name;

@end

NSInvocationOperation

NSInvocationOperation 通过 Invocation 的形式管理单个任务的执行。只能通过 initWithTarget:selector:object:的形式在初始化的时候指定 Targrt-Action。它实现了非并发的 Operation。

/ 系统提供的封装了 Invocation 的 NSOperation 实体类，默认新建线程异步执行
@interface NSInvocationOperation : NSOperation {

// 用 Action-Target 初始化 NSInvocationOperation
- (nullable instancetype)initWithTarget:(id)target selector:(SEL)sel object:(nullable id)arg;

// 用 NSInvocation 初始化 NSInvocationOperation，指定初始化方法
- (instancetype)initWithInvocation:(NSInvocation *)inv NS_DESIGNATED_INITIALIZER;

// 获取 invocation
@property (readonly, retain) NSInvocation *invocation;

// 获取运行结果。如果操作没有返回值、操作被取消或抛出了异常，访问此属性会抛出异常
@property (nullable, readonly, retain) id result;

@end

NSBlockOperation

NSBlockOperation 通过 Block 的形式管理多个任务并发执行。可以使用init创建然后通过addExecutionBlock添加多个 Block。也可以直接使用blockOperationWithBlock:创建并添加第一个 Block。它管理的 Block是、 可以通过数组executionBlocks获取。调用Start方法后数组中的所有的 Block 会并发执行，第一个Block在当前线程执行，其余会在新建的子线程执行。直到所有 Block 都执行完毕，NSBlockOperation 才算完成。

// 系统提供的封装了 Block 的 NSOperation 实体类，默认新建线程异步执行
@interface NSBlockOperation : NSOperation {

// 用 Block 初始化 NSBlockOperation
+ (instancetype)blockOperationWithBlock:(void (^)(void))block;

// 添加多个操作，默认新建线程异步执行
- (void)addExecutionBlock:(void (^)(void))block;

// 获取所有的 execution blocks
@property (readonly, copy) NSArray *executionBlocks;

@end

NSOpertionQueue

// 获取 NSInvocationOperation result 时操作被取消或没有返回值时抛出的异常名称
FOUNDATION_EXPORT NSExceptionName const NSInvocationOperationVoidResultException;
FOUNDATION_EXPORT NSExceptionName const NSInvocationOperationCancelledException;

NSOpertionQueue
// 操作的默认最大并发数，由 NSOperationQueue 基于当前系统状况动态确定
static const NSInteger NSOperationQueueDefaultMaxConcurrentOperationCount = -1;

// NSOperationQueue 通过队列管理多个 NSOperation 的执行
@interface NSOperationQueue : NSObject {

// 添加 Operation
- (void)addOperation:(NSOperation *)op;

// 添加多个 Operation，同步或异步执行
- (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait;

// 通过 Block 添加 Operation
- (void)addOperationWithBlock:(void (^)(void))block;

// 获取所有 Operation
@property (readonly, copy) NSArray<__kindof NSOperation *> *operations;
// 所有 Operation 数量
@property (readonly) NSUInteger operationCount;

// 最大并行数，等于1时代表串行队列
@property NSInteger maxConcurrentOperationCount;

// 暂停/恢复队列任务派发，获取暂停状态
@property (getter=isSuspended) BOOL suspended;

// 队列名称
@property (nullable, copy) NSString *name;

// 队列中 Operation 默认的优先级，如果 Operation 有自己设置的优先级则使用自己的优先级
// 默认 Background，主队列为 UserInteractive 且不能改变
@property NSQualityOfService qualityOfService;

// 用 dispatch_queue_t 派发任务。
// 默认 nil 且不能设置为 dispatch_get_main_queue()。
// 设置时 operationCount 必须为0，否则会抛出异常。
// dispatch_queue_t 的 qualityOfService 会覆盖 OperationQueue 的设置。
@property (nullable, assign /* actually retain */) dispatch_queue_t underlyingQueue;

// 取消所有 Operation
- (void)cancelAllOperations;

// 同步执行，阻塞当前线程直到所有任务完成
- (void)waitUntilAllOperationsAreFinished;

// 获取当前队列
@property (class, readonly, strong, nullable) NSOperationQueue *currentQueue;
// 获取主队列
@property (class, readonly, strong) NSOperationQueue *mainQueue;

@end

NSOperation的使用例子

NSInvocationOperation *op = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(run) object:nil];
[op start];

{number = 1, name = main}

如果仅仅是封装了操作，然后调用start方法，他是不会开启线程的。

    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"%@", [NSThread currentThread]);
    }];
    
    [op addExecutionBlock:^{
        NSLog(@"%@", [NSThread currentThread]);
    }];
    
    [op start];
    
    {number = 3, name = (null)}
    {number = 1, name = main}

和NSInvocationOperation一样，只是封装了操作并调用start方法，并不会开启线程，但如果通过addExecutionBlock方法添加新任务的时候，默认会开启新的线程并异步执行。

使用子类 NSBlockOperation，并调用方法 AddExecutionBlock: 的情况下，blockOperationWithBlock:方法中的操作 和 addExecutionBlock: 中的操作是在不同的线程中异步执行的。而且，这次执行结果中 blockOperationWithBlock:方法中的操作也不是在当前线程（主线程）中执行的。从而印证了blockOperationWithBlock: 中的操作也可能会在其他线程（非当前线程）中执行。

一般情况下，如果一个 NSBlockOperation 对象封装了多个操作。NSBlockOperation 是否开启新线程，取决于操作的个数。如果添加的操作的个数多，就会自动开启新线程。当然开启的线程数是由系统来决定的。

//创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    
    //创建操作
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(run) object:nil];
    NSInvocationOperation *op2 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(run) object:nil];
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"%@", [NSThread currentThread]);
    }];
    [op3 addExecutionBlock:^{
        NSLog(@"%@", [NSThread currentThread]);
    }];
    [op3 addExecutionBlock:^{
        NSLog(@"%@", [NSThread currentThread]);
    }];
    NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"%@", [NSThread currentThread]);
    }];
    
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];
    [queue addOperation:op4];

NSOperationQueue有两种队列:
主队列，凡是添加到主队列中的任务,都会在主线程执行

[NSOperationQueue mainQueue];

非主队列，同时包含了串行和并发的功能
就像上面的代码,把任务添加到队列以后,自动在子线程中执行
如果想用非主线程实现串行,则需要设置并发量

[[NSOperationQueue alloc]init];

设置最大并发数，设置为1的时候任务就会串行执行。

queue.maxConcurrentOperationCount = 2;

挂起

任务暂停
self.queue.suspended = YES;
任务开启
self.queue.suspended = NO;

取消任务
调用queue的cancelAllOperations方法相当于调用了queue中每个NSOperation的cancel方法，如果调用cancel方法的时候,NSOperation有一个任务正在执行，那么需要这个任务执行完了以后,再实现cancel。

[self.queue cancelAllOperations];

任务依赖和任务监听

NSBlockOperation *op5 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"download5----%@", [NSThread  currentThread]);
}];
//监听任务执行完毕后 进行其他操作
op5.completionBlock = ^{
    NSLog(@"op5执行完毕---%@", [NSThread currentThread]);
  };
    
// 设置依赖
[op3 addDependency:op1];
[op3 addDependency:op2];
[op3 addDependency:op4];

    //创建线程队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    //设置线程的最大并发数
    queue.maxConcurrentOperationCount = 2;
    //暂停queue，可以先将任务设置好优先级，依赖关系，全部添加到线程池中后再开启。
    queue.suspended = YES;
    //创建线程
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(thread1) object:nil];
    NSInvocationOperation *op2 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(thread2) object:nil];
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"---3---%@",[NSThread currentThread]);
    }];
    //设置线程的优先级
    op1.queuePriority = NSOperationQueuePriorityNormal;
    op2.queuePriority = NSOperationQueuePriorityHigh;
    op3.queuePriority = NSOperationQueuePriorityNormal;
    //设置线程的依赖关系
    [op1 addDependency:op3];
    //将线程添加到线程池中
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];
    //开启线程执行
    queue.suspended = NO;
    
    
    - (void)thread1{
    NSLog(@"---1---%@",[NSThread currentThread]);
    }
    - (void)thread2{
    NSLog(@"---2---%@",[NSThread currentThread]);
    }
    //打印结果
    ---2---{number = 3, name = (null)}
    ---3---{number = 4, name = (null)}
    ---1---{number = 5, name = (null)}

无需先创建操作，在 block 中添加操作，直接将包含操作的 block 加入到队列中。

    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    [queue addOperationWithBlock:^{
        NSLog(@"---2---%@",[NSThread currentThread]);
    }];
    //打印结果
    ---2---{number = 3, name = (null)}

线程间的通信，而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

- (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]); // 打印当前线程
            }
        }];
    }];
}

使用自定义继承自 NSOperation 的子类

如果使用子类 NSInvocationOperation、NSBlockOperation 不能满足日常需求，我们可以使用自定义继承自 NSOperation 的子类。可以通过重写 main 或者 start 方法 来定义自己的 NSOperation 对象。重写main方法比较简单，我们不需要管理操作的状态属性 isExecuting 和 isFinished。当 main 执行完返回的时候，这个操作就结束了。

#import 

NS_ASSUME_NONNULL_BEGIN

@interface MyOperation : NSOperation

@end

NS_ASSUME_NONNULL_END

#import "MyOperation.h"

@implementation MyOperation

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

@end

    MyOperation *op = [[MyOperation alloc]init];
    [op start];
    //打印结果
    1---{number = 1, name = main}
    1---{number = 1, name = main}
    //在没有使用 NSOperationQueue、在主线程单独使用自定义继承自 NSOperation 的子类的情况下，是在主线程执行操作，并没有开启新线程。
    
    MyOperation *op = [[MyOperation alloc]init];
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    [queue addOperation:op];
    //打印结果
    1---{number = 3, name = (null)}
    1---{number = 3, name = (null)}

NSOperation、NSOperationQueue 线程同步和线程安全

线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程同步：可理解为线程 A 和 线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。

NSOperation、NSOperationQueue 非线程安全

当两个线程队列queue同时执行时，并且对同一个量进行写的修改，可能出现同时修改的情况，此时就出现了数据的错乱，出现了非线程安全。

NSOperation、NSOperationQueue 线程安全

当出现上述情况的时候，说明非线程安全，解决方案可以给线程枷锁，当一个线程执行该操作的时候，不允许其他线程进行操作。

iOS 实现线程加锁有很多种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各种方式。这里我们使用 NSLock 对象来解决线程同步问题。NSLock 对象可以通过进入锁时调用 lock 方法，解锁时调用 unlock 方法来保证线程安全。

    //初始化
    self.lock = [[NSLock alloc] init];

    // 加锁
    [self.lock lock];
    
    //对数据进行操作的代码块

    // 解锁
    [self.lock unlock];