IOS多线程编程

参考自

1. http://blog.csdn.net/qinlicang/article/details/42221585

2. http://blog.csdn.net/lengshengren/article/details/12905787

3. http://my.oschina.net/aofe/blog/270093

正在进行中的程序被称为进程,负责程序运行的内存分配，每一个进程都有自己独立的虚拟内存空间.

线程:(主线程最大占1M的栈区空间,每条子线程最大占512K的栈区空间),线程是进程中一个独立的执行路径(控制单元);

一个进程中至少包含一条线程,即主线程; 可以将耗时的执行路径(如网络请求)放在其他线程中执行; 线程不能被杀掉,但是可以暂停/休眠一条线程.

GCD基本思想

    GCD的基本思想就是将操作S放在队列S中去执行.

    1> 操作使用Blocks定义;

    2> 队列负责调度任务执行所在的线程以及具体的执行时间;

    3> 队列的特点是先进先出(FIFO)的,新添加至队列的操作都会排在队尾.

提示:

    GCD的函数都是以dispatch(分派/调度)开头的.

队列:(串行和并行针对的是代码快的执行顺序而言)

    dispatch_queue_t

    串行队列: 队列中的任务只会顺序执行;

dispatch_queue_t queue = dispatch_queue_create("com.dispatch.serial", DISPATCH_QUEUE_SERIAL); //生成一个串行队列，队列中的block按照先进先出（FIFO）的顺序去执行，实际上为单线程执行。第一个参数是队列的名称，在调试程序时会非常有用，所有尽量不要重名了。

    并行队列: 队列中的任务通常会并发执行.

dispatch_queue_t queue = dispatch_queue_create("com.dispatch.concurrent", DISPATCH_QUEUE_CONCURRENT); //生成一个并发执行队列，block被分发到多个线程去执行

操作:（只要涉及异步操作就可能会创建多个线程）

    dispatch_async 异步操作,会并发执行,无法确定任务的执行顺序;

    dispatch_sync 同步操作,会依次顺序执行,能够决定任务的执行顺序.

   队列不是线程,也不表示对应的CPU.队列就是负责调度的.多线程技术的目的,就是为了在一个CPU上实现快速切换!

    异步解决了线程堵塞，而并发则是在异步的基础上，提高了符合特性事件的处理时间效率

在串行队列中:

    同步操作不会新建线程,操作顺序执行(没用!);

    异步操作会新建线程,操作顺序执行(非常有用!) (应用场景:既不影响主线程,又需要顺序执行的操作).

在并行队列中:

    同步操作不会新建线程,操作顺序执行;

    异步操作会新建多个线程,操作无序执行(有用,容易出错),队列前如果有其他任务,会等待前面的任务完成之后再执行.应用场景:既不影响主线程,又不需要顺序执行的操作.

全局队列:

    全局队列是系统的,直接拿过来(GET)用就可以,与并行对立类似,但调试时,无法确认操作所在队列.

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); //获得程序进程缺省产生的并发队列，可设定优先级来选择高、中、低三个优先级队列。由于是系统默认生成的，所以无法调用dispatch_resume()和dispatch_suspend()来控制执行继续或中断。需要注意的是，三个队列不代表三个线程，可能会有更多的线程。并发队列可以根据实际情况来自动产生合理的线程数，也可理解为dispatch队列实现了一个线程池的管理，对于程序逻辑是透明的。

    官网文档解释说共有三个并发队列，但实际还有一个更低优先级的队列，设置优先级为DISPATCH_QUEUE_PRIORITY_BACKGROUND。Xcode调试时可以观察到正在使用的各个dispatch队列

主队列:

    每一个应用程序都对应唯一一个主队列,直接GET即可,在多线程开发中,使用主队列更新UI;

dispatch_queue_t queue = dispatch_get_main_queue(); //获得主线程的dispatch队列，实际是一个串行队列。同样无法控制主线程dispatch队列的执行继续或中断。

注意:

    主队列中的操作都应该在主线程上顺序执行,不存在异步的概念.

    如果把主线程中的操作看作是一个大的Block,那么除非主线程被用户杀掉,否则永远不会结束.所以主队列中添加的同步操作永远不会被执行,会死锁.

不同队列中嵌套同步操作dispatch_sync的结果:

?

1

2

3

4

5

6

7

8

// 全局队列，都在主线程上执行，不会死锁

dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 并行队列，都在主线程上执行，不会死锁

dispatch_queue_t q = dispatch_queue_create("m.baidu.com", DISPATCH_QUEUE_CONCURRENT);

// 串行队列，会死锁，但是会执行嵌套同步操作之前的代码

dispatch_queue_t q = dispatch_queue_create("m.baidu.com", DISPATCH_QUEUE_SERIAL);

// 直接死锁

dispatch_queue_t q = dispatch_get_main_queue();

同步操作dispatch_sync的应用场景:

    阻塞并行队列的执行，要求某一操作执行后再进行后续操作，如用户登录.

    确保块代码之外的局部变量确实被修改.

    [NSThread sleepForTimeInterval:2.0f] 通常在多线程调试中用于模拟耗时操作,在发布的应用程序中，不要使用此方法！

    无论什么队列和什么任务,线程的创建和回收都不需要程序员参与.线程的创建回收工作是由队列负责的.

iOS的三种多线程技术特点:

1.NSThread:(旧的)

    1> 使用NSThread对象建立一个线程非常方便;

    2> 但是!要使用NSThread管理多个线程非常困难,不推荐使用;

    3> 技巧!使用[NSThread currentThread]跟踪任务所在线程,适用于这三种技术.

2.GCD---Grand Central Dispatch:

   Grand Central Dispatch (GCD)是Apple开发的一个多核编程的较新的解决方法。在Mac OS X 10.6雪豹中首次推出，并在最近引入到了iOS4.0。

    1> 是基于C语言的底层API;

    2> 用Block定义任务,使用起来非常灵活便捷;

    3> 提供了更多的控制能力以及操作队列中所不能使用的底层函数.

3.NSOperation/NSOperationQueue（AFN）:

    1> 是使用GCD实现的一套Objective-C的API;

    2> 是面向对象的多线程技术;

    3> 提供了一些在GCD中不容易实现的特性,如:限制最大并发数量,操作之间的依赖关系.

iOS的开发者需要了解三种多线程技术的基本使用,因为在实际开发中会根据实际情况选择不同的多线程技术.

简介:

    1> NSOperationQueue(操作队列)是由GCD提供的队列模型的Cocoa抽象,是一套Objective-C的API;

    2> GCD提供了更加底层的控制,而NSOperationQueue(操作队列)则在GCD之上实现了一些方便的功能,这些功能对开发者而言通常是最好最安全的选择.

队列及操作:

    NSOperationQueue有两种不同类型的队列:主队列和自定义队列.

    主队列运行在主线程上,自定义队列在后台执行.

    队列处理的任务是NSOperation的子类:NSInvocationOperation 和 NSBlockOperation.

NSOperation的基本使用步骤:

    定义操作队列 --> 定义操作 -->将操作添加到队列.

提示:

    一旦将操作添加到队列,操作就会立即被调度执行.

NSInvocationOperation(调度操作)

    1> 定义队列:

?

1

self.myQueue = [[NSOpertaionQueue alloc] init];

    2> 操作调用的方法:

?

1

2

3

4

-(void)operationAction:(id)obj

{

    NSLog(@"%@----obj : %@ ",[NSThread currentThread], obj);

};

    3> 定义操作并添加到队列:

?

1

2

3

NSInvocationOperation *op = [[NSInvocationOperation alloc] 

initWithTarget:self selector:@selector(operationAction:) object:@(i)];

[self.myQueue addOperation:op]

提示:需要准备一个被调度的方法,并且能够接收一个参数.

NSBlockOperation(块操作)

     定义操作并添加到队列:

?

1

2

3

4

NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{

    [self operationAction:@"Block Operation"];

}];

[self.myQueue addOperation:op];

    NSBlockOperation比NSInvocationOperation更加灵活;

设置操作的依赖关系:

    利用 " addDependency "可以指定操作之间彼此的依赖关系(执行先后顺序),但是注意不要出现循环依赖.

设置同时并发的线程数量:

?

1

[self.myQueue setMaxConcurrentOperationCount:2];

NSOperation小结:

    从本质上看,操作队列的性能会比GCD略低,不过,大多数情况下这点负面影响可以忽略不计.操作队列是并发编程的首选工具.

    在这里,推荐一个非常好用的第三方编程框架AFN,底层用GCD开发,开发的接口是NSOperation的，因此可以直接引用该网络库

声明和执行一个队列 
如下会返回一个用户创建的队列：

dispatch_queue_t myQueue = dispatch_queue_create("com.iphonedevblog.post", NULL); 

其中，第一个参数是标识队列的，第二个参数是用来定义队列的参数（目前不支持，因此传入NULL）。

执行一个队列 
如下会异步执行传入的代码：

dispatch_async(myQueue, ^{ [self doSomething]; }); 

其中，首先传入之前创建的队列，然后提供由队列运行的代码块。

从队列中在主线程运行代码 
有些操作无法在异步队列运行，因此必须在主线程（每个应用都有一个）上运行。UI绘图以及任何对NSNotificationCenter的调用必须在主线程长进行。在另一个队列中访问主线程并运行代码的示例如下：

dispatch_sync(dispatch_get_main_queue(), ^{ [self dismissLoginWindow]; }); 

注意，dispatch_suspend （以及dispatch_resume）在主线程上不起作用。

常用的方法dispatch_async

为了避免界面在处理耗时的操作时卡死，比如读取网络数据，IO,数据库读写等，我们会在另外一个线程中处理这些操作，然后通知主线程更新界面。

在功能实现中，如果不能保证UI代码运行在主线程中，那它可能就运行到其他地方去了，这样的话会出现几秒钟的延迟。

对于偶现或者必现的UI展示有延迟的情况，也可以尝试放在改队列操作中。

例如添加下面的代码可以让dismissal运行在主线程中：

dispatch_async(dispatch_get_main_queue(), ^{
  [self presentViewController:UINavigationController对象 animated:YES completion:nil]
});

dispatch_async(dispatch_get_main_queue(), ^{    [self dismissViewControllerAnimated:YES completion:nil]});

用GCD实现这个流程的操作比前面介绍的NSThread  NSOperation的方法都要简单。代码框架结构如下：

[cpp] view plaincopy

1. dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
2.     // 耗时的操作  
3.     dispatch_async(dispatch_get_main_queue(), ^{  
4.         // 更新界面  
5.     });  
6. });  

如果这样还不清晰的话，那我们还是用上两篇博客中的下载图片为例子，代码如下：

[cpp] view plaincopy

1. dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
2.     NSURL * url = [NSURL URLWithString:@"http://avatar.csdn.net/2/C/D/1_totogo2010.jpg"];  
3.     NSData * data = [[NSData alloc]initWithContentsOfURL:url];  
4.     UIImage *image = [[UIImage alloc]initWithData:data];  
5.     if (data != nil) {  
6.         dispatch_async(dispatch_get_main_queue(), ^{  
7.             self.imageView.image = image;  
8.          });  
9.     }  
10. });  

实际编程经验告诉我们，尽可能避免使用dispatch_sync，嵌套使用时还容易引起程序死锁。

如果queue1是一个串行队列的话，这段代码立即产生死锁(开始和结束等待依赖)：

   dispatch_sync(queue1, ^{

      dispatch_sync(queue1, ^{

　　　　......

　　});

　　......

　});

不妨思考下，为什么下面代码也肯定死锁：（main queue也是串行队列）

dispatch_sync(dispatch_get_main_queue(), ^{

　　......

}); 

 

那实际运用中，一般可以用dispatch这样来写，常见的网络请求数据多线程执行模型：

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

　　//子线程中开始网络请求数据

　　//更新数据模型

　　dispatch_sync(dispatch_get_main_queue(), ^{

　　　　//在主线程中更新UI代码

　　});

});

程序的后台运行和UI更新代码紧凑，代码逻辑一目了然。