iOS多线程——你要知道的NSOperation都在这里你要知道的iOS多线程NSThread、GCD、NSOperation、RunLoop都在这里

/*
对于并发Operation需要重写该方法
也可以不把operation加入到队列中，手动触发执行，与调用普通方法一样
*/
- (void)start;

/*
非并发Operation需要重写该方法
*/
- (void)main;

//只读属性任务是否取消，如果自定义子类，需要重写该属性
@property (readonly, getter=isCancelled) BOOL cancelled;

/*
设置cancelled属性为YES
仅仅标记cancelled属性，不退出任务，和NSThread的cancel一个机制
自定义子类时需要使用该属性判断是否在外部触发了取消任务的操作，手动退出任务
*/
- (void)cancel;

//只读属性，任务是否正在执行，如果自定义子类，需要重写该属性
@property (readonly, getter=isExecuting) BOOL executing;

/*
只读属性，任务是否结束，如果自定义子类，需要重写该方法
对于加入到队列的任务来说，当finished设置为YES后，队列会将任务移除出队列
*/
@property (readonly, getter=isFinished) BOOL finished;

//是否为并发任务，该属性已经被标识即将弃用，应该使用下面的asynchronous属性
@property (readonly, getter=isConcurrent) BOOL concurrent; // To be deprecated; use and override 'asynchronous' below

/*
只读属性，判断任务是否为并发任务，默认返回NO
如果需要自定义并发任务子类，需要重写getter方法返回YES
*/
@property (readonly, getter=isAsynchronous) BOOL asynchronous;

/*
只读属性，任务是否准备就绪
对于加入队列的任务，当ready为YES，标识该任务即将开始执行
如果任务有依赖的任务没有执行完成ready为NO
*/
@property (readonly, getter=isReady) BOOL ready;

/*
添加一个NSOperation为当前任务的依赖
如果一个任务有依赖，需要等待依赖的任务执行完成才能开始执行
*/
- (void)addDependency:(NSOperation *)op;

//删除一个依赖
- (void)removeDependency:(NSOperation *)op;

//任务在队列里的优先级
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0,
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
};

//任务在队列里的优先级
@property NSOperationQueuePriority queuePriority;

/*
任务完成后的回调方法
当finished属性设置为YES时才会执行该回调
*/
@property (nullable, copy) void (^completionBlock)(void);

//创建一个NSBlockOperation对象，传入一个block
NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
    for (int i = 0; i < 100; i++)
    {
        NSLog(@"Task1 %@ %d", [NSThread currentThread], i);
    }
}];

/*
创建一个NSInvocationOperation对象，指定执行的对象和方法
该方法可以接收一个参数即object
*/
NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task:) object:@"Hello, World!"];

//向队列中添加一个任务
- (void)addOperation:(NSOperation *)op;

/*
向队列中添加一组任务
是否等待任务完成，如果YES，则阻塞当前线程直到所有任务完成
如果为False，不阻塞当前线程
*/
- (void)addOperations:(NSArray<NSOperation *> *)ops waitUntilFinished:(BOOL)wait;

//向队列中添加一个任务，任务以block的形式传入，使用更方便
- (void)addOperationWithBlock:(void (^)(void))block;

//获取队列中的所有任务
@property (readonly, copy) NSArray<__kindof NSOperation *> *operations;

//获取队列中的任务数量
@property (readonly) NSUInteger operationCount;

/*
队列支持的最大任务并发数
如果为1，则只支持同时处理一个任务，即串行队列，主队列就是串行队列使用主线程执行任务
如果为大于1的数，则支持同时处理多个任务，即并发队列，底层使用线程池管理多个线程来执行任务
*/
@property NSInteger maxConcurrentOperationCount;

//队列是否挂起
@property (getter=isSuspended) BOOL suspended;

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

/*
取消队列中的所有任务
即所有任务都执行cancel方法，所有任务的cancelled属性都置为YES
*/
- (void)cancelAllOperations;

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

//类属性，获取当前队列
@property (class, readonly, strong, nullable) NSOperationQueue *currentQueue;

//类属性，获取主队列，任务添加到主队列就会使用主线程执行，主队列的任务并发数为1，即串行队列
@property (class, readonly, strong) NSOperationQueue *mainQueue;

- (void)task:(id)obj
{
    for (int i = 0; i < 100; i++)
    {
        NSLog(@"Task2 %@ %d %@", [NSThread currentThread], i, obj);
    }
}

- (void)viewWillAppear:(BOOL)animated
{
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    [queue setMaxConcurrentOperationCount:2];
    
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 100; i++)
        {
            NSLog(@"Task1 %@ %d", [NSThread currentThread], i);
        }
    }];
    
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task:) object:@"Hello, World!"];

    [queue addOperation:operation];
    [queue addOperation:invocationOperation];
}

Task2 <NSThread: 0x1c427e440>{number = 3, name = (null)} 0 Hello, World!
Task1 <NSThread: 0x1c0462fc0>{number = 4, name = (null)} 0

- (void)task:(id)obj
{
    for (int i = 0; i < 100; i++)
    {
        NSLog(@"Task5 %@ %d %@", [NSThread currentThread], i, obj);
    }
}

- (void)viewWillAppear:(BOOL)animated
{
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    [queue setMaxConcurrentOperationCount:4];
    
    NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 100; i++)
        {
            NSLog(@"Task1 %@ %d", [NSThread currentThread], i);
        }
    }];
    
    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 100; i++)
        {
            NSLog(@"Task2 %@ %d", [NSThread currentThread], i);
        }
    }];
    
    NSBlockOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 100; i++)
        {
            NSLog(@"Task3 %@ %d", [NSThread currentThread], i);
        }
    }];
    
    NSBlockOperation *operation4 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 100; i++)
        {
            NSLog(@"Task4 %@ %d", [NSThread currentThread], i);
        }
    }];
    
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task:) object:@"Hello, World!"];

    [operation2 addDependency:operation1];
    [operation3 addDependency:operation1];
    [operation4 addDependency:operation3];
    
    [queue addOperation:operation1];
    [queue addOperation:operation2];
    [queue addOperation:operation3];
    [queue addOperation:operation4];
    [queue addOperation:invocationOperation];
}

@interface TestOperation: NSOperation

@property (nonatomic, copy) id obj;

- (instancetype)initWithObject:(id)obj;

@end

@implementation TestOperation

- (instancetype)initWithObject:(id)obj
{
    if (self = [super init])
    {
        self.obj = obj;
    }
    return self;
}

- (void)main
{
    for (int i = 0; i < 100; i++)
    {
        NSLog(@"Task %@ %d %@", self.obj, i, [NSThread currentThread]);
    }
    NSLog(@"Task Complete!");
}

@end

- (void)viewWillAppear:(BOOL)animated
{
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    [queue setMaxConcurrentOperationCount:4];
    
    TestOperation *operation = [[TestOperation alloc] initWithObject:@"Hello, World!"];
    [operation main];
    //[operation start];
    //[queue addOperation:operation];
    
}

@interface MyOperation: NSOperation

@property (nonatomic, assign, getter=isExecuting) BOOL executing;
@property (nonatomic, assign, getter=isFinished) BOOL finished;

@end

@implementation MyOperation

@synthesize executing = _executing;
@synthesize finished = _finished;

- (void)start
{
    //在任务开始前设置executing为YES，在此之前可能会进行一些初始化操作
    self.executing = YES;
    for (int i = 0; i < 500; i++)
    {
        /*
        需要在适当的位置判断外部是否调用了cancel方法
        如果被cancel了需要正确的结束任务
        */
        if (self.isCancelled)
        {
            //任务被取消正确结束前手动设置状态
            self.executing = NO;
            self.finished = YES;
            return;
        }
        //输出任务的各个状态以及队列的任务数
        NSLog(@"Task %d %@ Cancel:%d Executing:%d Finished:%d QueueOperationCount:%ld", i, [NSThread currentThread], self.cancelled, self.executing, self.finished, [[NSOperationQueue currentQueue] operationCount]);
        [NSThread sleepForTimeInterval:0.1];
    }
    NSLog(@"Task Complete.");
    //任务执行完成后手动设置状态
    self.executing = NO;
    self.finished = YES;
}

- (void)setExecuting:(BOOL)executing
{
    //调用KVO通知
    [self willChangeValueForKey:@"isExecuting"];
    _executing = executing;
    //调用KVO通知
    [self didChangeValueForKey:@"isExecuting"];
}

- (BOOL)isExecuting
{
    return _executing;
}

- (void)setFinished:(BOOL)finished
{
    //调用KVO通知
    [self willChangeValueForKey:@"isFinished"];
    _finished = finished;
    //调用KVO通知
    [self didChangeValueForKey:@"isFinished"];
}

- (BOOL)isFinished
{
    return _finished;
}

- (BOOL)isAsynchronous
{
    return YES;
}

@end

- (void)cancelButtonClicked
{
    [self.myOperation cancel];
}

- (void)btnClicked
{
    NSLog(@"MyOperation Cancel:%d Executing:%d Finished:%d QueueOperationCount:%ld", self.myOperation.isCancelled, self.myOperation.isExecuting, self.myOperation.isFinished, self.queue.operationCount);    
}

- (void)viewWillAppear:(BOOL)animated
{
    self.queue = [[NSOperationQueue alloc] init];
    [self.queue setMaxConcurrentOperationCount:1];
    
    self.myOperation = [[MyOperation alloc] init];
    [self.queue addOperation:self.myOperation];
    
}

//任务的输出内容
Task 95 <NSThread: 0x1c027c780>{number = 3, name = (null)} Cancel:0 Executing:1 Finished:0 QueueOperationCount:1

//任务正在执行的时候，点击按钮的输出
MyOperation Cancel:0 Executing:1 Finished:0 QueueOperationCount:1

//当任务执行完成后，点击按钮的输出
MyOperation Cancel:0 Executing:0 Finished:1 QueueOperationCount:0

//FileDownloadOperation.h文件代码
#ifndef FileDownloadOperation_h
#define FileDownloadOperation_h

#import <Foundation/Foundation.h>

@class FileDownloadOperation;

//定义一个协议，用于反馈下载状态
@protocol FileDownloadDelegate <NSObject>

@optional
- (void)fileDownloadOperation:(FileDownloadOperation *)downloadOperation downloadProgress:(double)progress;
- (void)fileDownloadOperation:(FileDownloadOperation *)downloadOperation didFinishWithData:(NSData *)data;
- (void)fileDownloadOperation:(FileDownloadOperation *)downloadOperation didFailWithError:(NSError *)error;

@end

@interface FileDownloadOperation: NSOperation
//定义代理对象
@property (nonatomic, weak) id<FileDownloadDelegate> delegate;
//初始化构造函数，文件URL
- (instancetype)initWithURL:(NSURL*)url;

@end

#endif /* FileDownloadOperation_h */

#import "FileDownloadOperation.h"

@interface FileDownloadOperation() <NSURLConnectionDelegate>

//定义executing属性
@property (nonatomic, assign, getter=isExecuting) BOOL executing;
//定义finished属性
@property (nonatomic, assign, getter=isFinished) BOOL finished;

//要下载的文件的URL
@property (nonatomic, strong) NSURL *fileURL;
//使用NSURLConnection进行网络数据的获取
@property (nonatomic, strong) NSURLConnection *connection;
//定义一个可变的NSMutableData对象，用于添加获取的数据
@property (nonatomic, strong) NSMutableData *fileMutableData;
//记录要下载文件的总长度
@property (nonatomic, assign) NSUInteger fileTotalLength;
//记录已经下载了的文件的长度
@property (nonatomic, assign) NSUInteger downloadedLength;

@end

@implementation FileDownloadOperation

@synthesize delegate = _delegate;

@synthesize executing = _executing;
@synthesize finished = _finished;

@synthesize fileURL = _fileURL;
@synthesize connection = _connection;
@synthesize fileMutableData = _fileMutableData;
@synthesize fileTotalLength = _fileTotalLength;
@synthesize downloadedLength = _downloadedLength;

//executing属性的setter
- (void)setExecuting:(BOOL)executing
{
    //设置executing属性需要手动触发KVO方法进行通知
    [self willChangeValueForKey:@"executing"];
    _executing = executing;
    [self didChangeValueForKey:@"executing"];
}
//executing属性的getter
- (BOOL)isExecuting
{
    return _executing;
}
//finished属性的setter
- (void)setFinished:(BOOL)finished
{
    //同上，需要手动触发KVO方法进行通知
    [self willChangeValueForKey:@"finished"];
    _finished = finished;
    [self didChangeValueForKey:@"finished"];
}
//finished属性的getter
- (BOOL)isFinished
{
    return _finished;
}
//返回YES标识为并发Operation
- (BOOL)isAsynchronous
{
    return YES;
}
//内部函数，用于结束任务
- (void)finishTask
{
    //中断网络连接
    [self.connection cancel];
    //设置finished属性为YES，将任务从队列中移除
    //会调用setter方法，并触发KVO方法进行通知
    self.finished = YES;
    //设置executing属性为NO
    self.executing = NO;
}
//初始化构造函数
- (instancetype)initWithURL:(NSURL *)url
{
    if (self = [super init])
    {
        self.fileURL = url;
        
        self.fileMutableData = [[NSMutableData alloc] init];
        self.fileTotalLength = 0;
        self.downloadedLength = 0;
    }
    return self;
}
//重写start方法
- (void)start
{
    //任务开始执行前检查是否被取消，取消就结束任务
    if (self.isCancelled)
    {
        [self finishTask];
        return;
    }
    //构造NSURLConnection对象，并设置不立即开始，手动开始
    self.connection = [[NSURLConnection alloc] initWithRequest:[[NSURLRequest alloc] initWithURL:self.fileURL cachePolicy:NSURLRequestReloadIgnoringCacheData timeoutInterval:25] delegate:self startImmediately:NO];
    //判断是否连接，没有连接就结束任务
    if (self.connection == nil)
    {
        [self finishTask];
        return;
    }
    //成功连接到服务器后检查是否取消任务，取消任务就结束
    if (self.isCancelled)
    {
        [self finishTask];
        return;
    }
    //设置任务开始执行
    self.executing = YES;
    //获取当前RunLoop
    NSRunLoop *currentRunLoop = [NSRunLoop currentRunLoop];
    //将任务交由RunLoop规划
    [self.connection scheduleInRunLoop:currentRunLoop forMode:NSRunLoopCommonModes];
    //开始从服务端获取数据
    [self.connection start];
    //判断执行任务的是否为主线程
    if (currentRunLoop != [NSRunLoop mainRunLoop])
    {
        //不为主线程启动RunLoop
        CFRunLoopRun();
    }
}

//MARK - NSURLConnectionDelegate 方法

- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response
{
    //获取并设置将要下载文件的长度大小
    self.fileTotalLength = response.expectedContentLength;
}

- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error
{
    //网络获取失败，调用代理方法
    if ([self.delegate respondsToSelector:@selector(fileDownloadOperation:didFailWithError:)])
    {
        //需要将代理方法放到主线程中执行，防止代理方法需要修改UI
        dispatch_async(dispatch_get_main_queue(), ^{
            [self.delegate fileDownloadOperation:self didFailWithError:error];
        });
    }
}

- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data
{
    //收到数据包后判断任务是否取消，取消则结束任务
    if (self.isCancelled)
    {
        [self finishTask];
        return;
    }
    //添加获取的数据
    [self.fileMutableData appendData:data];
    //修改已下载文件长度
    self.downloadedLength += [data length];
    //调用回调函数
    if ([self.delegate respondsToSelector:@selector(fileDownloadOperation:downloadProgress:)])
    {
        //计算下载比例
        double progress = self.downloadedLength * 1.0 / self.fileTotalLength;
        //同上，放在主线程中调用，防止主线程有修改UI的操作
        dispatch_async(dispatch_get_main_queue(), ^{
            [self.delegate fileDownloadOperation:self downloadProgress:progress];
        });
    }
}

- (void)connectionDidFinishLoading:(NSURLConnection *)connection
{
    //网络下载完成前检查是否取消任务，取消就结束任务
    if (self.isCancelled)
    {
        [self finishTask];
        return;
    }
    //调用回调函数
    if ([self.delegate respondsToSelector:@selector(fileDownloadOperation:didFinishWithData:)])
    {
        //同理，放在主线程中调用
        dispatch_async(dispatch_get_main_queue(), ^{
            [self.delegate fileDownloadOperation:self didFinishWithData:self.fileMutableData];
        });
    }
    //下载完成，任务结束
    [self finishTask];
}

@end