IOS高级编程之三：IOS 多线程编程

多线程的概念在各个操作系统上都会接触到，windows、Linux、mac os等等这些常用的操作系统，都支持多线程的概念。

当然ios中也不例外，但是线程的运行节点可能是我们平常不太注意的。

例如：

 - (void)viewDidLoad
 {
     [super viewDidLoad];
     for(int i =  ; i <  ; i++)
     {
         NSLog(@"===%@===%d" , [NSThread currentThread].name , i);
         if(i == )
         {
             // 创建线程对象
             NSThread *thread = [[NSThread alloc]initWithTarget:self
                 selector:@selector(run) object:nil];
             // 启动新线程
             [thread start];
 //            // 创建并启动新线程
 //            [NSThread detachNewThreadSelector:@selector(run) toTarget:self
 //                withObject:nil];
         }
     }
 }
 - (void)run
 {
     for(int i =  ; i <  ; i++)
     {
         NSLog(@"-----%@----%d" , [NSThread currentThread].name, i);
     }
 }

上面打印的内容每一次都是不同的，什么意思呢？

当我们创建了4个线程后，加上UI主线程一共5个线程。

新的线程在执行start方法之后，并不会立即执行。他们会被cpu随机的执行，只是间隔非常短，以至于我们感觉上是多个线程在同时执行。

所以线程有这么一个特点：执行的随机性。

但是我们可以设置线程的优先级，让优先级更高的线程获得更多的执行机会。

那么什么时候要使用多线程编程呢？

相信有过开发经验的程序员都知道，当我们把代码写完后，程序是一行一行逐行执行代码的，当其中一行代码需要执行较长时间（例如select一个教复杂的语句或者较多的数据时），那么程序就会出现卡顿的现象，不会相应用户的操作。

因为开启程序后会默认开启一个主线程，即UI线程。当处于刚才那种情况时，比如一个windows程序，就会出现程序暂时无响应的提示，好像电脑卡主的感觉，这是非常不好的一种感受。。。。

当我们要避免这种情况的时候，最好的方式就是多线程，开启一个新的线程，用来执行一个耗时的操作，执行完成后再让主线程来修改ui页面（如果需要的话）。

介绍完了线程的一些知识，那么下面来具体看ios中多线程的几种实现方式，主要有一下三种：

1、NSThread ：就是刚刚例子中使用的方式，但是使用上比较繁琐，而且需要控制好数据的同步和异步问题

2、NSOperation 和 NSOperationQueue ： 这种方式代码比较简洁，可读性强，而且使用队列的形式管理多个任务，本人比较喜欢

3、使用GCD( Grand Central Dispatch ) ：相较于NSThread使用简单，使用队列管理任务

一、首先来介绍NSThread

1、创建NSThread的两种方式

-(id) initWithTarget:(id) target selector:(SEL) selector object:(id) arg:

+(void)detachNewThreadSelector:(SEL) selector toTarget:(id) target withObject:(id) arg:

第二种方式，创建NSThread后会自动启动

2、NSThread的常用方法

+currentThread ： 返回当前正在执行的线程对象

3、线程的状态

一开始的例子中提了一下，线程创建后，执行了start方法并不是立即就执行了。可能ui线程执行了几毫秒后，cpu才执行它，执行几毫秒后再执行ui线程，但这个过程是随机发生的。

如果想让线程立即执行，那么可以让ui线程sleep 1毫秒，这样cpu就会执行其他可执行的线程，可以达到立即执行的效果

 [NSThread sleepForTimeInterval:0.001];//让当前运行的线程睡眠1毫秒

线程正在执行时，调用isExecuting方法返回 YES ，线程执行完成后调用 isFinished 方法就会返回 YES

4、终止子线程

线程会以一下3种方式之一结束，结束后就处于死亡状态

1）线程执行的方法体执行完成，线程正常结束

2）执行过程中出现了错误

3）调用NSThread 类的 exit 方法来终止当前线程

在UI 线程中 ，NSThread 并没有提供方法来结束其他的子线程。但是我们可以利用 NSThread 的cancel 方法，执行该方法后， 该线程的状态为 isCancelled = YES，但并不会结束线程。

 NSThread* thread;
 - (void)viewDidLoad
 {
     [super viewDidLoad];
     // 创建新线程对象
     thread = [[NSThread alloc] initWithTarget:self selector:@selector(run)
         object:nil];
     // 启动新线程
     [thread start];
 }
 - (void)run
 {
     for(int i =  ; i <  ; i++)
     {
         if([NSThread currentThread].isCancelled)
         {
             // 终止当前正在执行的线程
             [NSThread exit];
         }
         NSLog(@"-----%@----%d" , [NSThread currentThread].name, i);
         // 每执行一次，线程暂停0.5秒
         [NSThread sleepForTimeInterval:0.5];
     }
 }
 - (IBAction)cancelThread:(id)sender
 {
     // 取消thread线程，调用该方法后，thread的isCancelled方法将会返回NO
     [thread cancel];
 }

利用例子中代码的形式，我们就可以达到在UI线程中结束其他子线程的目的了。

5、线程睡眠

要让线程进入阻塞状态或者睡眠状态，可以执行sleepXXX格式的方法：

+(void) sleepUntilDate:(NSDate *) aDate  : 让线程睡眠，知道aDate那个时间点再醒过来

-(void)sleepForTimeInterval ：让线程睡眠多少秒

6、改变线程优先级

NSThread 提供了如下几个方法来获取和设置线程的优先级

+threadPriority: 获取当前正在执行的线程的优先级

-threadPriority：获取线程实例的优先级

+setThreadPriority :(double) priority ： 设置当前正在执行的线程的优先级

-setThreadPriority :(double) priority ： 设置线程实例的优先级

(double) priority的 取值范围是0.0~1.0；优先级越高的线程获得的执行机会越多

 - (void)viewDidLoad
 {
     [super viewDidLoad];
     NSLog(@"UI线程的优先级为：%g" , [NSThread threadPriority]);
     // 创建第一个线程对象
     NSThread* thread1 = [[NSThread alloc]
         initWithTarget:self selector:@selector(run) object:nil];
     // 设置第一个线程对象的名字
     thread1.name = @"线程A";
     NSLog(@"线程A的优先级为：%g" , thread1.threadPriority);
     // 设置使用最低优先级
     thread1.threadPriority = 0.0;
     // 创建第二个线程对象
     NSThread* thread2 = [[NSThread alloc]
         initWithTarget:self selector:@selector(run) object:nil];
     // 设置第二个线程对象的名字
     thread2.name = @"线程B";
     NSLog(@"线程B的优先级为：%g" , thread2.threadPriority);
     // 设置使用最高优先级
     thread2.threadPriority = 1.0;
     // 启动2个线程
     [thread1 start];
     [thread2 start];
 }
 - (void)run
 {
     for(int i =  ; i <  ; i++)
     {
         NSLog(@"-----%@----%d" , [NSThread currentThread].name, i);
     }
 }

二、使用GCD实现多线程

GCD简化了多线程的实现，主要有两个核心概念：

1、队列：队列负责管理开发者提交的任务，以先进先出的方式来处理任务。

1）串行队列：每次只执行一个任务，当前一个任务执行完成后才执行下一个任务

2）并行队列：多个任务并发执行，所以先执行的任务可能最后才完成（因为具体的执行过程导致）

2、任务：任务就是开发者提供给队列的工作单元，这些任务将会提交给队列底层维护的线程池，因此这些任务将会以多线程的方式执行。

3、创建队列

1）获取系统默认的全局并发队列：

 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, );

2) 获取系统主线程关联的穿行队列

 dispatch_queue_t queue = dispatch_get_main_queue();

如果将任务提交给主线程关联的串行队列，那么就相当于在程序主线程中去执行该任务。

3)创建穿行队列

 dispatch_queue_t queue = dispatch_queue_create("queueName", DISPATCH_QUEUE_SERIAL);

4)创建并发队列

 dispatch_queue_t queue = dispatch_queue_create("queueName", DISPATCH_QUEUE_CONCURRENT);

5)获取当前执行代码所在队列

dispatch_get_current_queue，返回一个dispatch_queue_t类型的值

4、提交任务

使用下面的方法将任务以同步或者异步的方式提交到队列

 //将代码块以异步的方式提交给指定队列
 void  dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

 //将函数以异步的方式提交给指定队列，一般执行函数的方法与执行代码块的方法比，方法名多了一个_f的后缀
 void  dispatch_async_f(dispatch_queue_t queue, void* context, dispatch_function_t work);

 //将代码块以同步的方式提交给指定队列
 void  dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

 //将函数以同步的方式提交给指定队列，一般执行函数的方法与执行代码块的方法比，方法名多了一个_f的后缀
 void  dispatch_sync_f(dispatch_queue_t queue, void* context, dispatch_function_t work);

 //将代码块以异步的方式提交给指定队列，队列的线程池负责在指定时间点 when 之后执行
 void  dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block);

 //将函数以异步的方式提交给指定队列，队列的线程池负责在指定时间点 when 之后执行
 void  dispatch_after_f(dispatch_time_t when, dispatch_queue_t queue,  void* context, dispatch_function_t work);

 //将代码块以异步的方式提交给指定队列，队列的线程池将会重复多次执行该任务
 void  dispatch_apply(size_t iterations, dispatch_queue_t queue, void(^block)(size_t));

 //将函数以异步的方式提交给指定队列，队列的线程池将会重复多次执行该任务
 void  dispatch_apply_f(size_t iterations, dispatch_queue_t queue, void* context, void(*work)(void*, size_t));

 //将代码块提交给指定队列，在应用的某个生命周期内金执行一次
 void dispatch_once(dispatch_once_t *predicate, dispatch_block_t block);

下面给出一个以异步方式向串行队列、并发队列添加任务的实例

 // 定义2个队列
 dispatch_queue_t serialQueue;
 dispatch_queue_t concurrentQueue;
 - (void)viewDidLoad
 {
     [super viewDidLoad];
     // 创建串行队列
     serialQueue = dispatch_queue_create("fkjava.queue", DISPATCH_QUEUE_SERIAL);
     // 创建并发队列
     concurrentQueue = dispatch_queue_create("fkjava.queue"
         , DISPATCH_QUEUE_CONCURRENT);
 }
 - (IBAction)serial:(id)sender
 {
     // 依次将2个代码块提交给串行队列
     // 必须等到第1个代码块完成后，才能执行第2个代码块。
     dispatch_async(serialQueue, ^(void)
     {
         for (int i =  ; i < ; i ++)
         {
             NSLog(@"%@=====%d"  , [NSThread currentThread] , i);
         }
     });
     dispatch_async(serialQueue, ^(void)
     {
         for (int i =  ; i < ; i ++)
         {
             NSLog(@"%@------%d" , [NSThread currentThread] , i);
         }
     });
 }
 - (IBAction)concurrent:(id)sender
 {
     // 依次将2个代码块提交给并发队列
     // 两个代码块可以并发执行
     dispatch_async(concurrentQueue, ^(void)
     {
         for (int i =  ; i < ; i ++)
         {
             NSLog(@"%@=====%d"  , [NSThread currentThread] , i);
         }
     });
     dispatch_async(concurrentQueue, ^(void)
     {
         for (int i =  ; i < ; i ++)
         {
             NSLog(@"%@------%d" , [NSThread currentThread] , i);
         }
     });
 }

提交同步任务：

 - (void)viewDidLoad
 {
     [super viewDidLoad];
 }
 - (IBAction)clicked:(id)sender
 {
     // 以同步方式先后提交2个代码块
     dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, )
         , ^(void){
             for (int i =  ; i < ; i ++)
             {
                 NSLog(@"%@=====%d"  , [NSThread currentThread] , i);
                 [NSThread sleepForTimeInterval:0.1];
             }
         });
     // 必须等第一次提交的代码块执行完成后，dispatch_sync()函数才会返回，
     // 程序才会执行到这里，才能提交第二个代码块。
     dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, )
         , ^(void){
             for (int i =  ; i < ; i ++)
             {
                 NSLog(@"%@-----%d"  , [NSThread currentThread] , i);
                 [NSThread sleepForTimeInterval:0.1];
             }
         });
 }

多次执行的任务：

 - (void)viewDidLoad
 {
     [super viewDidLoad];
 }
 - (IBAction)clicked:(id)sender
 {
     // 控制代码块执行5次
     dispatch_apply(
         , dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, )
         // time形参代表当前正在执行第几次
         , ^(size_t time)
         {
             NSLog(@"===执行【%lu】次===%@" , time
                 , [NSThread currentThread]);
         });
 }

只执行一次的任务

 @implementation FKViewController
 - (void)viewDidLoad
 {
     [super viewDidLoad];
 }
 - (IBAction)clicked:(id)sender
 {
     static dispatch_once_t onceToken;
     dispatch_once(&onceToken, ^{
         NSLog(@"==执行代码块==");
         // 线程暂停3秒
         [NSThread sleepForTimeInterval:];
     });
 }

三、使用NSOperation 和 NSOPerationQueue 实现多线程

和GCD差不多，也是有队列和任务的概念

NSOperationQueue：代表一个先进先出的队列，负责管理系统提交的多个NSOperation。底层维护一个线程池，会按顺序启动线程来执行提交给队列的NSOperation

NSOperation：代表多线程任务。一般不直接使用NSOperation，而是使用NSOperation的子类。或者使用NSInvocationOperation和NSBlockOperation（这两个类继承自NSOperation）；

1、NSOperation的使用

NSOperation 的使用相较于GCD是面向对象的，OC实现的，而GCD应该是C实现的（看函数的定义和使用）。

使用NSOperation 只需两步：

1）创建 NSOperationQueue 队列，并未该队列设置相关属性

2）创建 NSOperation 子类对象，并将该对象提交给 NSOperationQueue 队列，该队列将会按顺序依次启动每个 NSOperation。

2、NSOperationQueue的常用方法：

 +currentQueue //类方法，返回执行当前NSOperation的NSOperationQueue队列

 +mainQueue //返回系统主线程的NSOperationQueue队列

 -(void) addOperation:(NSOperation *) operation //将operation添加到NSOperationQueue队列中

 -(void) addOperations:(NSArray *) ops waitUnitlFinished:(BOLL) wait //将NSArray中包含的所有NSOperation添加到NSOperationQueue。如果第二个参数指定为YES，将会阻塞当前线程，直到提交的所有NSOperation执行完成。如果第二个参数为NO，该方法立即返回，NSArray包含的NSOperation将以异步方式执行，不会阻塞当前线程。

 - operations //只读属性，返回该NSOperationQueue管理的所有NSOperation
 -operationCount //只读属性，返回该NSOperationQueue管理的所有NSOperation数量

 -cancelAllOperations: //取消NSOperationQueue队列中所有正在排队和执行的NSOperation

 -waitUntilAllOperationsAreFinished://阻塞当前线程，直到该NSOperationQueue中所有排队和执行的NSOperation执行完成再接触阻塞

 -(NSInteger) maxConcurrentOperationCount://返回该队列最大支持多少个并发线程

 -setMaxConcurrentOperationCount:(NSInteger) count //设置该队列最大支持多少个并发线程

 -setSuspended:(BOOL) suspend: //设置NSOperationQueue是否已经暂停调度正在排队的NSOperation

 -(BOLL) isSuspended: //返回NSOperationQueue是否已经暂停调度正在排队的NSOperation

3、使用NSInvocationOperation 和 NSBlockOperation

NSInvocationOperation 和 NSBlockOperation 继承自 NSOperation，所以可以直接使用，用于封装需要异步执行的任务。

使用它们实现图片异步下载：

 NSOperationQueue* queue;
 - (void)viewDidLoad
 {
     [super viewDidLoad];
     queue = [[NSOperationQueue alloc]init];
     // 设置该队列最多支持10条并发线程
     queue.maxConcurrentOperationCount = ;
 }
 - (IBAction)clicked:(id)sender
 {
     NSString* url = @"http://www.......jpg";
     // 以传入的代码块作为执行体，创建NSOperation
     NSBlockOperation* operation = [NSBlockOperation
         blockOperationWithBlock:^{
             // 从网络获取数据
             NSData *data = [[NSData alloc]
                 initWithContentsOfURL:[NSURL URLWithString:url]];
             // 将网络数据初始化为UIImage对象
             UIImage *image = [[UIImage alloc]initWithData:data];
             if(image != nil)
             {
                 // 在主线程中执行updateUI:方法
                 [self performSelectorOnMainThread:@selector(updateUI:)
                     withObject:image waitUntilDone:YES];
             }
             else
             {
                 NSLog(@"---下载图片出现错误---");
             }
         }];
     // 将NSOperation添加给NSOperationQueue
     [queue addOperation:operation];
 }
 -(void)updateUI:(UIImage*) image
 {
     self.iv.image = image;
 }

 NSOperationQueue* queue;
 - (void)viewDidLoad
 {
     [super viewDidLoad];
     queue = [[NSOperationQueue alloc]init];
     // 设置该队列最多支持10条并发线程
     queue.maxConcurrentOperationCount = ;
 }
 - (IBAction)clicked:(id)sender
 {
     NSString* url = @"http://www.......jpg";
     // 以self的downloadImageFromURL:方法作为执行体，创建NSOperation
     NSInvocationOperation* operation = [[NSInvocationOperation alloc]
         initWithTarget:self selector:@selector(downloadImageFromURL:)
         object:url];
     // 将NSOperation添加给NSOperationQueue
     [queue addOperation:operation];
 }

 // 定义一个方法作为线程执行体。
 -(void)downloadImageFromURL:(NSString *) url
 {
     // 从网络获取数据
     NSData *data = [[NSData alloc]
         initWithContentsOfURL:[NSURL URLWithString:url]];
     // 将网络数据初始化为UIImage对象
     UIImage *image = [[UIImage alloc]initWithData:data];
     if(image != nil)
     {
         // 在主线程中执行updateUI:方法
         [self performSelectorOnMainThread:@selector(updateUI:)
             withObject:image waitUntilDone:YES];
     }
     else
     {
         NSLog(@"---下载图片出现错误---");
     }
 }
 -(void)updateUI:(UIImage*) image
 {
     self.iv.image = image;
 }

4、自定义NSOperation 的子类

创建 NSOperation 的子类，需要重写一个方法：-(void) main，该方法的方法体将作为 NSOperationQueue 完成的任务

下面自定义一个NSOperation 子类来实现下载图片的功能

 @interface MyDownImageOperation : NSOperation
 @property (nonatomic , strong) NSURL* url;
 @property (nonatomic , weak) UIImageView* imageView;
 - (id)initWithURL:(NSURL*)url imageView:(UIImageView*)iv;
 @end

 @implementation MyDownImageOperation
 - (id)initWithURL:(NSURL*)url imageView:(UIImageView*)iv
 {
     self = [super init];
     if (self) {
         _imageView = iv;
         _url = url;
     }
     return self;
 }
 // 重写main方法，该方法将作为线程执行体
 - (void)main
 {
     // 从网络获取数据
     NSData *data = [[NSData alloc]
         initWithContentsOfURL:self.url];
     // 将网络数据初始化为UIImage对象
     UIImage *image = [[UIImage alloc]initWithData:data];
     if(image != nil)
     {
         // 在主线程中执行updateUI:方法
         [self performSelectorOnMainThread:@selector(updateUI:)
             withObject:image waitUntilDone:YES]; // ①
     }
     else
     {
         NSLog(@"---下载图片出现错误---");
     }
 }
 -(void)updateUI:(UIImage*) image
 {
     self.imageView.image = image;
 }

viewController代码：

 NSOperationQueue* queue;
 - (void)viewDidLoad
 {
     [super viewDidLoad];
     queue = [[NSOperationQueue alloc]init];
     // 设置该队列最多支持10条并发线程
     queue.maxConcurrentOperationCount = ;
 }
 - (IBAction)clicked:(id)sender
 {
     // 定义要加载的图片的URL
     NSURL* url = [NSURL URLWithString:@"http://www.crazyit.org/logo.jpg"];
     // 创建FKDownImageOperation对象
     MyDownImageOperation* operation = [[MyDownImageOperation alloc]
         initWithURL:url imageView:self.iv];
     // 将NSOperation的子类的实例提交给NSOperationQueue
     [queue addOperation:operation];
 }