1，NSOperation使用
1）NSOperation简介
NSOperation是Cocoa中的一个抽象类，用来封装单个任务和代码执行一项操作，由于是抽象类，所以不能直接实例化使用，必须定义子类继承该抽象类来实现，比较常用的NSOperation的子类有NSInvocationOperation，另外，也可以自己继承NSOperation来实现线程的操作。
另外会使用到操作队列NSOperationQueue，它相当于一个线程队列或者可以叫做线程池，可以顺序执行队列中的操作，也可以设置队列中操作的优先级。
NSOperation有两个子类，NSInvocationOperation 和 NSBlockOperation。NSOperation也是设计用来扩展的，只需继承重写NSOperation的一个方法main。
2）NSOperation和GCD
/**
GCD --> IOS4.0
-GCD --> iOS 4.0
- 将任务（block）添加到队列（串行/并发(全局)），指定 执行任务的方法(同步(阻塞)/异步)
- 拿到 dispatch_get_main_queue()。 线程间通信
- NSOperation无法做到，一次性执行，延迟执行，调度组(op相对复杂)
NSOperation ----> iOS 2.0 （后来苹果改造了NSOperation的底层）
- 将操作(异步执行)添加到队列(并发/全局)
- [NSOperationQueue mainQueue] 主队列。 任务添加到主队列， 就会在主线程执行
- 提供了一些GCD不好实现的，”最大并发数“
- 暂停/继续 --- 挂起
- 取消所有的任务
- 依赖关系
*/
/**
小结一下:
只要是NSOperation的子类 就能添加到操作队列
- 一旦操作添加到队列， 就会自动异步执行
- 如果没有添加到队列, 而是使用start方法，会在当前线程执行操作
- 如果要做线程间通信，可以使用[NSOperationQueue mainQueue]拿到主队列，往主队列添加操作(更新UI)
*/3）NSOperation多线程Demo
基本用法
#pragma mark - 基本使用
// MARK : 线程间通信 最重要的代码
// 线程间的通信，代码实现，子线程中获取主线程，并在主线程中添加操作，可以嵌套
- (void)opDemo5
{
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperationWithBlock:^{
NSLog(@"耗时操作");
[NSThread sleepForTimeInterval:2];
//去主线程更新UI
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
NSLog(@"更新UI");
}];
}];
}
//MARk : NSBlockOperation使用
// 如下所示，NSBlockOperation，NSInvocationOperation两种对象可以同时放到一个队列中执行的，就是说是可以混合使用的
- (void)opDemo4
{
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
for (int i = 0; i < 10; i++) {
//直接使用队列的方法将操作添加到队列中去
[queue addOperationWithBlock:^{
[NSThread sleepForTimeInterval:1];
NSLog(@"%@", [NSThread currentThread]);
}];
}
//创建一个NSBlockOperation操作对象
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
[NSThread sleepForTimeInterval:1];
NSLog(@"op1-----%@", [NSThread currentThread]);
}];
//他们两个的执行顺序是不确定的
[op1 addExecutionBlock:^{
[NSThread sleepForTimeInterval:1];
NSLog(@"op1---op1");
}];
[queue addOperation:op1];
//创建并添加 NSInvocationOperation
NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downloadImage:) object:@"abc"];
[queue addOperation:op2];
}
//MARK : NSBlockOperation使用
- (void)opDemo3
{
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
//获取主队列， 和GCD中的主队列一个道理
NSOperationQueue *q = [NSOperationQueue mainQueue];
for (int i = 0; i < 10; i++) {
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
[NSThread sleepForTimeInterval:1];
NSLog(@"%@", [NSThread currentThread]);
}];
[queue addOperation:op];
}
NSLog(@"done");
}
//MARK : 多个 NSInvocationOperation 使用
- (void)opDemo2
{
//队列，在GCD中并发(全局)队列使用的最多。所以NSoperation技术直接把GCD里面的并发队列封装起来
//NSOperationQueue队列，本质就是GCD里面的并发队列
//操作就是GCD里面异步执行任务
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
//把多个操作放到队列中去
for(int i = 0; i < 10; i++)
{
NSOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downloadImage:) object:@"sdsdsd"];
[queue addOperation:op];
}
}
// MARK : 单个 NSInvocationOperation 的使用
- (void)opDemo1
{
//1,创建操作
NSOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downloadImage:) object:@"downloadImage"];
//2，启动 使用这个方法时候，会直接在当前线程中执行任务，达不到多线程的目的
// [op start];
//3,只要把操作添加到队列中， 就会自动的异步执行
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:op];
NSLog(@"111%s", __func__);
}
- (void)downloadImage:(NSString *)picName
{
// NSLog(@"%s", __func__);
[NSThread sleepForTimeInterval:1];
NSLog(@"%@ ----- %@", [NSThread currentThread], picName);
}
高级用法
#pragma mark - 高级操作
// MARk : 依赖关系
- (void)dependecy
{
/*
例如：
1，登陆账号
2，下载一张图片，
3，图片更新到UI上
这三个操作是有先后顺序的， 为了处理并发中的这种先后顺序，需要使用依赖关系
*/
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"1,登陆账号 %@", [NSThread currentThread]);
}];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"2,下载一张图片 %@", [NSThread currentThread]);
}];
NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"3,更绣UI %@", [NSThread currentThread]);
}];
[op2 addDependency:op1];
[op3 addDependency:op2];
//如果出现循环依赖，程序就会死锁
// [op3 addDependency:op1];
//watiUntilFinished 类似GCD调度组的通知
//NO 不等待，会直接执行
//YES 等待上面的操作执行结束，再 执行
[self.queue addOperations:@[op1, op2] waitUntilFinished:YES];
NSLog(@"test");
//在主线程中更新UI
[[NSOperationQueue mainQueue] addOperation:op3];
NSLog(@"here");
}
// MARK : 取消队列中所有的操作
// 取消操作并不会影响队列的挂起状态
- (IBAction)cancleAll:(id)sender{
//取消队列中所有操作
[self.queue cancelAllOperations];
NSLog(@"取消当前队列中所有的操作");
//取消队列的挂起状态
self.queue.suspended = NO;
}
// MARK : 暂停/继续 对队列中任务的暂停和继续
- (IBAction)pause:(id)sender
{
//判断操作的数量，看队列中是不是有操作
if (self.queue.operationCount == 0) {
NSLog(@"没有操作");
return;
}
// 暂停/继续
self.queue.suspended = !self.queue.suspended;
// 队列挂起以后队列中的任务还是有的
if (self.queue.suspended) {
NSLog(@"暂停");
}else{
NSLog(@"继续");
}
}
// MARk : 最大并发数
- (void)opDemo6
{
//设置最大并发数，并不是线程的数量
// 这里设置最大并发数量，设置的是最多同时有多少个线程在执行，这里有个线程池的概念，当程序需要线程的时候，就会从线程池中取出一个线程，线程使用完毕时候还会放回线程池中去，在需要的识货再去线程池中取，线程使用的过程中还有个回收的过程
self.queue.maxConcurrentOperationCount = 3;
for (int i = 0; i < 20; i++) {
NSOperation *op = [NSBlockOperation blockOperationWithBlock:^{
[NSThread sleepForTimeInterval:1.0];
NSLog(@"%@---%d", [NSThread currentThread], i);
}];
[self.queue addOperation:op];
}
}
2，NSOperation
<pre name="code" class="objc">@interface NSOperation : NSObject {
@private
id _private;
int32_t _private1;
#if __LP64__
int32_t _private1b;
#endif
}
//1,通过这个方法可以启动一个操作，但是操作只会在当前的线程中执行，相当于是同步执行
- (void)start;
- (void)main;
//2,取消当前的操作
@property (readonly, getter=isCancelled) BOOL cancelled;
- (void)cancel;
@property (readonly, getter=isExecuting) BOOL executing; //判断当前操作是否正在执行
@property (readonly, getter=isFinished) BOOL finished; //判断当前操作是否执行完成
@property (readonly, getter=isConcurrent) BOOL concurrent; // To be deprecated; use and override 'asynchronous' below
@property (readonly, getter=isAsynchronous) BOOL asynchronous NS_AVAILABLE(10_8, 7_0);
@property (readonly, getter=isReady) BOOL ready;
//3,添加依赖关系 和 移除依赖关系
- (void)addDependency:(NSOperation *)op;
- (void)removeDependency:(NSOperation *)op;
//4,获取当前操作所有的依赖关系
@property (readonly, copy) NSArray *dependencies;
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
NSOperationQueuePriorityVeryLow = -8L,
NSOperationQueuePriorityLow = -4L,
NSOperationQueuePriorityNormal = 0,
NSOperationQueuePriorityHigh = 4,
NSOperationQueuePriorityVeryHigh = 8
};
//5,设置当前操作的优先级
@property NSOperationQueuePriority queuePriority;
//6,设置当前操作完成之后要执行的代码
@property (copy) void (^completionBlock)(void) NS_AVAILABLE(10_6, 4_0);
//7，等待完成之后继续操作
- (void)waitUntilFinished NS_AVAILABLE(10_6, 4_0);
@property double threadPriority NS_DEPRECATED(10_6, 10_10, 4_0, 8_0);
@property NSQualityOfService qualityOfService NS_AVAILABLE(10_10, 8_0);
@property (copy) NSString *name NS_AVAILABLE(10_10, 8_0);
@end3，NSBlockOperation
@interface NSBlockOperation : NSOperation {
@private
id _private2;
void *_reserved2;
}
//1,类方法创建一个操作
+ (instancetype)blockOperationWithBlock:(void (^)(void))block;
//2，向这个操作中添加子操作，子操作和当前操作执行顺序是不确定的，子操作和当前操作并没有什么联系。
- (void)addExecutionBlock:(void (^)(void))block;
@property (readonly, copy) NSArray *executionBlocks;
@end4，NSInvocationOperation
@interface NSInvocationOperation : NSOperation {
@private
id _inv;
id _exception;
void *_reserved2;
}
//1,通过一个实例方法，创建一个操作，并制定操作要执行的方法，缺点是，必须指定一个要执行的方法，异步执行的代码块要放到一个新的方法中去执行。
- (instancetype)initWithTarget:(id)target selector:(SEL)sel object:(id)arg;
- (instancetype)initWithInvocation:(NSInvocation *)inv NS_DESIGNATED_INITIALIZER;
@property (readonly, retain) NSInvocation *invocation;
@property (readonly, retain) id result;
@end5，NSOperationQueue
<pre name="code" class="objc">@interface NSOperationQueue : NSObject {
@private
id _private;
void *_reserved;
}
//1，向队列中添加操作
- (void)addOperation:(NSOperation *)op;
//2,使用数组的方式，向队列中添加操作，并设置是否对等待
- (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait NS_AVAILABLE(10_6, 4_0);
//3，通过block代码块来向队列中添加操作，一种更快捷的方式，无需创建NSOperation对象
- (void)addOperationWithBlock:(void (^)(void))block NS_AVAILABLE(10_6, 4_0);
//4,取出队列中的操作，只读
@property (readonly, copy) NSArray *operations;
//5，队列中的操作数（任务数）
@property (readonly) NSUInteger operationCount NS_AVAILABLE(10_6, 4_0);
//6,队列中最大并发数，最多能够同时执行多少个任务
@property NSInteger maxConcurrentOperationCount;
enum {
NSOperationQueueDefaultMaxConcurrentOperationCount = -1
};
//7,挂起，将队列中的任务挂起，暂停任务，挂起之后，队列中的任务不再 取出执行，但是任务还存在在队列中
@property (getter=isSuspended) BOOL suspended;
@property (copy) NSString *name NS_AVAILABLE(10_6, 4_0);
@property NSQualityOfService qualityOfService NS_AVAILABLE(10_10, 8_0);
@property (assign /* actually retain */) dispatch_queue_t underlyingQueue NS_AVAILABLE(10_10, 8_0);
//8,取消所有的操作
- (void)cancelAllOperations;
//9,相当于是GCD调度组中的通知，在队列中所有的任务都执行完成之后会调用这个方法
- (void)waitUntilAllOperationsAreFinished;
//10，获取当前所在队列，获取主队列
+ (NSOperationQueue *)currentQueue NS_AVAILABLE(10_6, 4_0);
+ (NSOperationQueue *)mainQueue NS_AVAILABLE(10_6, 4_0);
@end
399
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
