Objective-C的NSOperation多线程类基本使用指南

nsoperation

一、nsoperation
1.简介
nsoperation实例封装了需要执行的操作和执行操作所需的数据，并且能够以并发或非并发的方式执行这个操作。
nsoperation本身是抽象基类，因此必须使用它的子类，使用nsoperation子类的方式有2种：
1> foundation框架提供了两个具体子类直接供我们使用:nsinvocationoperation和nsblockoperation
2> 自定义子类继承nsoperation，实现内部相应的方法

2.执行操作
nsoperation调用start方法即可开始执行操作，nsoperation对象默认按同步方式执行,也就是在调用start方法的那个线程中直接执行。nsoperation对象的isconcurrent方法会告诉我们这个操作相对于调用start方法的线程,是同步还是异步执行。isconcurrent方法默认返回no,表示操作与调用线程同步执行

3.取消操作
operation开始执行之后, 默认会一直执行操作直到完成，我们也可以调用cancel方法中途取消操作

[operation cancel]; 

4.监听操作的执行
如果我们想在一个nsoperation执行完毕后做一些事情，就调用nsoperation的setcompletionblock方法来设置想做的事情

operation.completionblock = ^() { 
    nslog(@"执行完毕"); 
}; 

或者

[operation setcompletionblock:^() { 
    nslog(@"执行完毕"); 
}]; 

二、nsinvocationoperation
1.简介
基于一个对象和selector来创建操作。如果你已经有现有的方法来执行需要的任务,就可以使用这个类

2.创建并执行操作

// 这个操作是：调用self的run方法 
nsinvocationoperation *operation = [[nsinvocationoperation alloc] initwithtarget:self selector:@selector(run) object:nil]; 
// 开始执行任务(同步执行) 
[operation start]; 

三、nsblockoperation
1.简介
能够并发地执行一个或多个block对象，所有相关的block都执行完之后,操作才算完成

2.创建并执行操作

nsblockoperation *operation = [nsblockoperation blockoperationwithblock:^(){ 
        nslog(@"执行了一个新的操作，线程：%@", [nsthread currentthread]); 
}]; 
 // 开始执行任务(这里还是同步执行) 
[operation start]; 

3.通过addexecutionblock方法添加block操作

nsblockoperation *operation = [nsblockoperation blockoperationwithblock:^(){ 
    nslog(@"执行第1次操作，线程：%@", [nsthread currentthread]); 
}]; 
 
[operation addexecutionblock:^() { 
    nslog(@"又执行了1个新的操作，线程：%@", [nsthread currentthread]); 
}]; 
 
[operation addexecutionblock:^() { 
    nslog(@"又执行了1个新的操作，线程：%@", [nsthread currentthread]); 
}]; 
 
[operation addexecutionblock:^() { 
    nslog(@"又执行了1个新的操作，线程：%@", [nsthread currentthread]); 
}]; 
 
// 开始执行任务 
[operation start]; 

打印信息如下：

2013-02-02 21:38:46.102 thread[4602:c07] 又执行了1个新的操作，线程：<nsthread: 0x7121d50>{name = (null), num = 1} 
2013-02-02 21:38:46.102 thread[4602:3f03] 又执行了1个新的操作，线程：<nsthread: 0x742e1d0>{name = (null), num = 5} 
2013-02-02 21:38:46.102 thread[4602:1b03] 执行第1次操作，线程：<nsthread: 0x742de50>{name = (null), num = 3} 
2013-02-02 21:38:46.102 thread[4602:1303] 又执行了1个新的操作，线程：<nsthread: 0x7157bf0>{name = (null), num = 4} 

可以看出，这4个block是并发执行的，也就是在不同线程中执行的，num属性可以看成是线程的id

四、自定义nsoperation
1.简介
如果nsinvocationoperation和nsblockoperation对象不能满足需求, 你可以直接继承nsoperation, 并添加任何你想要的行为。继承所需的工作量主要取决于你要实现非并发还是并发的nsoperation。定义非并发的nsoperation要简单许多,只需要重载-(void)main这个方法，在这个方法里面执行主任务,并正确地响应取消事件; 对于并发nsoperation, 你必须重写nsoperation的多个基本方法进行实现（这里暂时先介绍非并发的nsoperation）

2.非并发的nsoperation
比如叫做downloadoperation，用来下载图片
1> 继承nsoperation，重写main方法，执行主任务
downloadoperation.h

#import <foundation/foundation.h> 
@protocol downloadoperationdelegate; 
 
@interface downloadoperation : nsoperation 
// 图片的url路径 
@property (nonatomic, copy) nsstring *imageurl; 
// 代理 
@property (nonatomic, retain) id<downloadoperationdelegate> delegate; 
 
- (id)initwithurl:(nsstring *)url delegate:(id<downloadoperationdelegate>)delegate; 
@end 

 
// 图片下载的协议 
@protocol downloadoperationdelegate <nsobject> 
- (void)downloadfinishwithimage:(uiimage *)image; 
@end 

downloadoperation.m

#import "downloadoperation.h" 
 
@implementation downloadoperation 
@synthesize delegate = _delegate; 
@synthesize imageurl = _imageurl; 
 
// 初始化 
- (id)initwithurl:(nsstring *)url delegate:(id<downloadoperationdelegate>)delegate { 
    if (self = [super init]) { 
        self.imageurl = url; 
        self.delegate = delegate; 
    } 
    return self; 
} 
// 释放内存 
- (void)dealloc { 
    [super dealloc]; 
    [_delegate release]; 
    [_imageurl release]; 
} 
 
// 执行主任务 
- (void)main { 
    // 新建一个自动释放池，如果是异步执行操作，那么将无法访问到主线程的自动释放池 
    @autoreleasepool { 
        // .... 
    } 
} 
@end 

2> 正确响应取消事件
operation开始执行之后,会一直执行任务直到完成,或者显式地取消操作。取消可能发生在任何时候,甚至在operation执行之前。尽管nsoperation提供了一个方法,让应用取消一个操作,但是识别出取消事件则是我们自己的事情。如果operation直接终止, 可能无法回收所有已分配的内存或资源。因此operation对象需要检测取消事件,并优雅地退出执行
nsoperation对象需要定期地调用iscancelled方法检测操作是否已经被取消,如果返回yes(表示已取消),则立即退出执行。不管是自定义nsoperation子类,还是使用系统提供的两个具体子类,都需要支持取消。iscancelled方法本身非常轻量,可以频繁地调用而不产生大的性能损失
以下地方可能需要调用iscancelled:
* 在执行任何实际的工作之前
* 在循环的每次迭代过程中,如果每个迭代相对较长可能需要调用多次
* 代码中相对比较容易中止操作的任何地方
downloadoperation的main方法实现如下

- (void)main { 
    // 新建一个自动释放池，如果是异步执行操作，那么将无法访问到主线程的自动释放池 
    @autoreleasepool { 
        if (self.iscancelled) return; 
         
        // 获取图片数据 
        nsurl *url = [nsurl urlwithstring:self.imageurl]; 
        nsdata *imagedata = [nsdata datawithcontentsofurl:url]; 
         
        if (self.iscancelled) { 
            url = nil; 
            imagedata = nil; 
            return; 
        } 
         
        // 初始化图片 
        uiimage *image = [uiimage imagewithdata:imagedata]; 
         
        if (self.iscancelled) { 
            image = nil; 
            return; 
        } 
         
        if ([self.delegate respondstoselector:@selector(downloadfinishwithimage:)]) { 
            // 把图片数据传回到主线程 
            [(nsobject *)self.delegate performselectoronmainthread:@selector(downloadfinishwithimage:) withobject:image waituntildone:no]; 
        } 
    } 
} 

nsoperationqueue
一、简介
一个nsoperation对象可以通过调用start方法来执行任务，默认是同步执行的。也可以将nsoperation添加到一个nsoperationqueue(操作队列)中去执行，而且是异步执行的。
创建一个操作队列：

nsoperationqueue *queue = [[nsoperationqueue alloc] init]; 

二、添加nsoperation到nsoperationqueue中
1.添加一个operation

[queue addoperation:operation]; 

2.添加一组operation

[queue addoperations:operations waituntilfinished:no]; 

3.添加一个block形式的operation

[queue addoperationwithblock:^() { 
    nslog(@"执行一个新的操作，线程：%@", [nsthread currentthread]); 
}]; 

nsoperation添加到queue之后,通常短时间内就会得到运行。但是如果存在依赖,或者整个queue被暂停等原因,也可能需要等待。
注意：nsoperation添加到queue之后,绝对不要再修改nsoperation对象的状态。因为nsoperation对象可能会在任何时候运行,因此改变nsoperation对象的依赖或数据会产生不利的影响。你只能查看nsoperation对象的状态, 比如是否正在运行、等待运行、已经完成等

三、添加nsoperation的依赖对象
1.当某个nsoperation对象依赖于其它nsoperation对象的完成时，就可以通过adddependency方法添加一个或者多个依赖的对象，只有所有依赖的对象都已经完成操作，当前nsoperation对象才会开始执行操作。另外，通过removedependency方法来删除依赖对象。

[operation2 adddependency:operation1]; 

依赖关系不局限于相同queue中的nsoperation对象,nsoperation对象会管理自己的依赖, 因此完全可以在不同的queue之间的nsoperation对象创建依赖关系

唯一的限制是不能创建环形依赖，比如a依赖b，b依赖a，这是错误的

2.依赖关系会影响到nsoperation对象在queue中的执行顺序，看下面的例子：
1> 没有设置依赖关系

nsoperationqueue *queue = [[nsoperationqueue alloc] init]; 
 
nsblockoperation *operation1 = [nsblockoperation blockoperationwithblock:^(){ 
    nslog(@"执行第1次操作，线程：%@", [nsthread currentthread]); 
}]; 
 
nsblockoperation *operation2 = [nsblockoperation blockoperationwithblock:^(){ 
    nslog(@"执行第2次操作，线程：%@", [nsthread currentthread]); 
}]; 
 
[queue addoperation:operation1]; 
[queue addoperation:operation2]; 

打印信息：

2013-02-03 00:21:35.024 thread[5616:3d13] 执行第1次操作，线程：<nsthread: 0x7658570>{name = (null), num = 3} 
2013-02-03 00:21:35.063 thread[5616:1303] 执行第2次操作，线程：<nsthread: 0x765a2e0>{name = (null), num = 4} 

可以看出，默认是按照添加顺序执行的，先执行operation1，再执行operation2

2> 设置了依赖关系

nsoperationqueue *queue = [[nsoperationqueue alloc] init]; 
 
nsblockoperation *operation1 = [nsblockoperation blockoperationwithblock:^(){ 
    nslog(@"执行第1次操作，线程：%@", [nsthread currentthread]); 
}]; 
 
nsblockoperation *operation2 = [nsblockoperation blockoperationwithblock:^(){ 
    nslog(@"执行第2次操作，线程：%@", [nsthread currentthread]); 
}]; 
// operation1依赖于operation2 
[operation1 adddependency:operation2]; 
 
[queue addoperation:operation1]; 
[queue addoperation:operation2]; 

打印信息：

2013-02-03 00:24:16.260 thread[5656:1b03] 执行第2次操作，线程：<nsthread: 0x7634490>{name = (null), num = 3} 
2013-02-03 00:24:16.285 thread[5656:1303] 执行第1次操作，线程：<nsthread: 0x9138b50>{name = (null), num = 4} 

可以看出，先执行operation2，再执行operation1

四、修改operations的执行顺序
对于添加到queue中的operations，它们的执行顺序取决于2点：
1.首先看看nsoperation是否已经准备好：是否准备好由对象的依赖关系确定
2.然后再根据所有nsoperation的相对优先级来确定。优先级等级则是operation对象本身的一个属性。默认所有operation都拥有“普通”优先级,不过可以通过setqueuepriority:方法来提升或降低operation对象的优先级。优先级只能应用于相同queue中的operations。如果应用有多个operation queue,每个queue的优先级等级是互相独立的。因此不同queue中的低优先级操作仍然可能比高优先级操作更早执行。
注意：优先级不能替代依赖关系,优先级只是对已经准备好的 operations确定执行顺序。先满足依赖关系,然后再根据优先级从所有准备好的操作中选择优先级最高的那个执行。

五、设置队列的最大并发操作数量
队列的最大并发操作数量，意思是队列中最多同时运行几条线程
虽然nsoperationqueue类设计用于并发执行operations,你也可以强制单个queue一次只能执行一个operation。setmaxconcurrentoperationcount:方法可以配置queue的最大并发操作数量。设为1就表示queue每次只能执行一个操作。不过operation执行的顺序仍然依赖于其它因素,比如operation是否准备好和operation的优先级等。因此串行化的operation queue并不等同于gcd中的串行dispatch queue

// 每次只能执行一个操作 
queue.maxconcurrentoperationcount = 1; 
// 或者这样写 
[queue setmaxconcurrentoperationcount:1]; 

六、取消operations
一旦添加到operation queue,queue就拥有了这个operation对象并且不能被删除,唯一能做的事情是取消。你可以调用operation对象的cancel方法取消单个操作,也可以调用operation queue的cancelalloperations方法取消当前queue中的所有操作。

// 取消单个操作 
[operation cancel]; 
 
// 取消queue中所有的操作 
[queue cancelalloperations]; 

七、等待options完成
为了最佳的性能,你应该设计你的应用尽可能地异步操作,让应用在operation正在执行时可以去处理其它事情。如果需要在当前线程中处理operation完成后的结果,可以使用nsoperation的waituntilfinished方法阻塞当前线程，等待operation完成。通常我们应该避免编写这样的代码,阻塞当前线程可能是一种简便的解决方案,但是它引入了更多的串行代码,限制了整个应用的并发性,同时也降低了用户体验。绝对不要在应用主线程中等待一个operation,只能在第二或次要线程中等待。阻塞主线程将导致应用无法响应用户事件,应用也将表现为无响应。

// 会阻塞当前线程，等到某个operation执行完毕 
[operation waituntilfinished]; 

除了等待单个operation完成,你也可以同时等待一个queue中的所有操作,使用nsoperationqueue的waituntilalloperationsarefinished方法。注意：在等待一个 queue时,应用的其它线程仍然可以往queue中添加operation,因此可能会加长线程的等待时间。

// 阻塞当前线程，等待queue的所有操作执行完毕 
[queue waituntilalloperationsarefinished]; 

八、暂停和继续queue
如果你想临时暂停operations的执行,可以使用queue的setsuspended:方法暂停queue。不过暂停一个queue不会导致正在执行的operation在任务中途暂停,只是简单地阻止调度新operation执行。你可以在响应用户请求时,暂停一个queue来暂停等待中的任务。稍后根据用户的请求,可以再次调用setsuspended:方法继续queue中operation的执行

// 暂停queue 
[queue setsuspended:yes]; 
 
// 继续queue 
[queue setsuspended:no];