程序博客网 > 淘宝网夏季竹凉席坐垫

iOS多线程---GCD

来源：互联网 发布：淘宝网夏季竹凉席坐垫 编辑：程序博客网 时间：2024/05/29 16:13

转自:http://blog.csdn.net/shubinniu/article/details/53004672


概念


队列 (dispatch_queue_t)

队列名称在调试时辅助，无论什么队列和任务，线程的创建和回收不需要程序员操作，有队列负责。


串行队列：


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


dispatch_queue_t q = dispatch_queue_create(“....”,DISPATCH_QUEUE_SERIAL);


并行队列：


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


dispatch_queue_t q =dispatch_queue_create("......",DISPATCH_QUEUE_CONCURRENT);


全局队列：


是系统的，直接拿过来（GET）用就可以；与并行队列类似，但调试时，无法确认操作所在队列


dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);


主队 列：


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


dispatch_queue_t q = dispatch_get_main_queue();


操  作:


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


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


备  注：


全局队列可认为是并行队列的一个特例，这里不再列举。

线程、任务和队列对比

异步、同步 & 并行、串行的特点


一条重要的准则

一般来说，我们使用GCD的最大目的是在新的线程中同时执行多个任务，这意味着我们需要两项条件：

  • 能开启新的线程
  • 任务可以同时执行
  • 结合以上两个条件，也就等价“开启新线程的能力 + 任务同步执行的权利”，只有在满足能力与权利这两个条件的前提下，我们才可以在同时执行多个任务。

所有组合的特点



（一）异步执行 + 并行队列

实现代码：

[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //异步执行 + 并行队列  
  2. - (void)asyncConcurrent{  
  3.     //创建一个并行队列  
  4.     dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_CONCURRENT);  
  5.   
  6.     NSLog(@"---start---");  
  7.   
  8.     //使用异步函数封装三个任务  
  9.     dispatch_async(queue, ^{  
  10.         NSLog(@"任务1---%@", [NSThread currentThread]);  
  11.     });  
  12.     dispatch_async(queue, ^{  
  13.         NSLog(@"任务2---%@", [NSThread currentThread]);  
  14.     });  
  15.     dispatch_async(queue, ^{  
  16.         NSLog(@"任务3---%@", [NSThread currentThread]);  
  17.     });  
  18.   
  19.     NSLog(@"---end---");  
  20. }  
打印结果：
[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. ---start---  
  2.   ---end---  
  3.   任务3---<NSThread: 0x600000070f00>{number = 5, name = (null)}  
  4.   任务2---<NSThread: 0x600000070d80>{number = 4, name = (null)}  
  5.   任务1---<NSThread: 0x608000074100>{number = 3, name = (null)}  
解释
  • 异步执行意味着
    • 可以开启新的线程
    • 任务可以先绕过不执行，回头再来执行
  • 并行队列意味着
    • 任务之间不需要排队，且具有同时被执行的“权利”
  • 两者组合后的结果
    • 开了三个新线程
    • 函数在执行时，先打印了start和end，再回头执行这三个任务
    • 这三个任务是同时执行的，没有先后，所以打印结果是“任务3-->任务2-->任务1”
步骤图


（二）异步执行 + 串行队列

实现代码：

[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //异步执行 + 串行队列  
  2. - (void)asyncSerial{  
  3.     //创建一个串行队列  
  4.     dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_SERIAL);  
  5.   
  6.     NSLog(@"---start---");  
  7.     //使用异步函数封装三个任务  
  8.     dispatch_async(queue, ^{  
  9.         NSLog(@"任务1---%@", [NSThread currentThread]);  
  10.     });  
  11.     dispatch_async(queue, ^{  
  12.         NSLog(@"任务2---%@", [NSThread currentThread]);  
  13.     });  
  14.     dispatch_async(queue, ^{  
  15.         NSLog(@"任务3---%@", [NSThread currentThread]);  
  16.     });  
  17.     NSLog(@"---end---");  
  18. }  

打印结果：
[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. ---start---  
  2.  ---end---  
  3. 任务1---<NSThread: 0x608000078480>{number = 3, name = (null)}  
  4. 任务2---<NSThread: 0x608000078480>{number = 3, name = (null)}  
  5. 任务3---<NSThread: 0x608000078480>{number = 3, name = (null)}  
解释
  • 异步执行意味着
    • 可以开启新的线程
    • 任务可以先绕过不执行，回头再来执行
  • 串行队列意味着
    • 任务必须按添加进队列的顺序挨个执行
  • 两者组合后的结果
    • 开了一个新的子线程
    • 函数在执行时，先打印了start和end，再回头执行这三个任务
    • 这三个任务是按顺序执行的，所以打印结果是“任务1-->任务2-->任务3”
步骤图


（三）同步执行 + 并行队列

实现代码：
[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //同步执行 + 并行队列  
  2. - (void)syncConcurrent{  
  3.     //创建一个并行队列  
  4.     dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_CONCURRENT);  
  5.   
  6.     NSLog(@"---start---");  
  7.     //使用同步函数封装三个任务  
  8.     dispatch_sync(queue, ^{  
  9.         NSLog(@"任务1---%@", [NSThread currentThread]);  
  10.     });  
  11.     dispatch_sync(queue, ^{  
  12.         NSLog(@"任务2---%@", [NSThread currentThread]);  
  13.     });  
  14.     dispatch_sync(queue, ^{  
  15.         NSLog(@"任务3---%@", [NSThread currentThread]);  
  16.     });  
  17.     NSLog(@"---end---");  
  18. }  

打印结果：
[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. ---start---  
  2.   任务1---<NSThread: 0x608000065400>{number = 1, name = main}  
  3.   任务2---<NSThread: 0x608000065400>{number = 1, name = main}  
  4.   任务3---<NSThread: 0x608000065400>{number = 1, name = main}  
  5.   ---end---  

解释
  • 同步执行执行意味着
    • 不能开启新的线程
    • 任务创建后必须执行完才能往下走
  • 并行队列意味着
    • 任务必须按添加进队列的顺序挨个执行
  • 两者组合后的结果
    • 所有任务都只能在主线程中执行
    • 函数在执行时，必须按照代码的书写顺序一行一行地执行完才能继续
  • 注意事项
    • 在这里即便是并行队列，任务可以同时执行，但是由于只存在一个主线程，所以没法把任务分发到不同的线程去同步处理，其结果就是只能在主线程里按顺序挨个挨个执行了
步骤图


（四）同步执行+ 串行队列

实现代码：
[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. - (void)syncSerial{  
  2.     //创建一个串行队列  
  3.     dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_SERIAL);  
  4.   
  5.     NSLog(@"---start---");  
  6.     //使用异步函数封装三个任务  
  7.     dispatch_sync(queue, ^{  
  8.         NSLog(@"任务1---%@", [NSThread currentThread]);  
  9.     });  
  10.     dispatch_sync(queue, ^{  
  11.         NSLog(@"任务2---%@", [NSThread currentThread]);  
  12.     });  
  13.     dispatch_sync(queue, ^{  
  14.         NSLog(@"任务3---%@", [NSThread currentThread]);  
  15.     });  
  16.     NSLog(@"---end---");  
  17. }  

打印结果：
[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. ---start---  
  2. 任务1---<NSThread: 0x608000065400>{number = 1, name = main}  
  3. 任务2---<NSThread: 0x608000065400>{number = 1, name = main}  
  4. 任务3---<NSThread: 0x608000065400>{number = 1, name = main}  
  5. ---end---  

解释
这里的执行原理和步骤图跟“同步执行+并发队列”是一样的，只要是同步执行就没法开启新的线程，所以多个任务之间也一样只能按顺序来执行

（五）异步执行+主队列

实现代码：
[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. - (void)asyncMain{  
  2.     //获取主队列  
  3.     dispatch_queue_t queue = dispatch_get_main_queue();  
  4.   
  5.     NSLog(@"---start---");  
  6.     //使用异步函数封装三个任务  
  7.     dispatch_async(queue, ^{  
  8.         NSLog(@"任务1---%@", [NSThread currentThread]);  
  9.     });  
  10.     dispatch_async(queue, ^{  
  11.         NSLog(@"任务2---%@", [NSThread currentThread]);  
  12.     });  
  13.     dispatch_async(queue, ^{  
  14.         NSLog(@"任务3---%@", [NSThread currentThread]);  
  15.     });  
  16.     NSLog(@"---end---");  
  17. }  

打印结果：
[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. ---start---  
  2. ---end---  
  3. 任务1---<NSThread: 0x60800006ff40>{number = 1, name = main}  
  4. 任务2---<NSThread: 0x60800006ff40>{number = 1, name = main}  
  5. 任务3---<NSThread: 0x60800006ff40>{number = 1, name = main}  

解释
  • 异步执行意味着
    • 可以开启新的线程
    • 任务可以先绕过不执行，回头再来执行
  • 主队列跟串行队列的区别
    • 队列中的任务一样要按顺序执行
    • 主队列中的任务必须在主线程中执行，不允许在子线程中执行
  • 以上条件组合后得出结果：
    • 所有任务都可以先跳过，之后再来“按顺序”执行
步骤图

（六）同步执行+主队列（死锁）

实现代码：
[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. - (void)syncMain{  
  2.     //获取主队列  
  3.     dispatch_queue_t queue = dispatch_get_main_queue();  
  4.   
  5.     NSLog(@"---start---");  
  6.     //使用同步函数封装三个任务  
  7.     dispatch_sync(queue, ^{  
  8.         NSLog(@"任务1---%@", [NSThread currentThread]);  
  9.     });  
  10.     dispatch_sync(queue, ^{  
  11.         NSLog(@"任务2---%@", [NSThread currentThread]);  
  12.     });  
  13.     dispatch_sync(queue, ^{  
  14.         NSLog(@"任务3---%@", [NSThread currentThread]);  
  15.     });  
  16.     NSLog(@"---end---");  
  17. }  

打印结果：
[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. ---start---  

解释
  • 主队列中的任务必须按顺序挨个执行
  • 任务1要等主线程有空的时候（即主队列中的所有任务执行完）才能执行
  • 主线程要执行完“打印end”的任务后才有空
  • “任务1”和“打印end”两个任务互相等待，造成死锁
步骤图


（七）知识拓展

1.  dispatch_sync同步应用场景

[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. -(void)loginAction  
  2. {  
  3.     //阻塞并行队列的执行，要求某一操作执行后再进行后续操作，如用户登录  
  4.     //确保块代码之外的局部变量确实被修改  
  5.     dispatch_queue_t q = dispatch_queue_create("cn.login", DISPATCH_QUEUE_CONCURRENT);  
  6.     __block BOOL logon = NO;  
  7.     dispatch_sync(q, ^{  
  8.         NSLog(@"模拟耗时操作 %@", [NSThread currentThread]);  
  9.         [NSThread sleepForTimeInterval:2.0f];  
  10.         NSLog(@"模拟耗时完成 %@", [NSThread currentThread]);  
  11.         logon = YES;  
  12.     });  
  13.       
  14.     dispatch_async(q, ^{  
  15.           
  16.         NSLog(@"登录完成的处理 %@", [NSThread currentThread]);  
  17.     });  
  18. }  

2.  iOS三种多线程技术：

 　　1.NSThread

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

 　　　　(2)但是！要使用NSThread管理多个线程非常困难，不推荐使用

 　　　　(3)技巧！使用[NSThread currentThread]跟踪任务所在线程，适用于这三种技术

 　　2.NSOperation/NSOperationQueue

 　　　　(1)是使用GCD实现的一套Objective-C的API

 　　　　(2)是面向对象的线程技术

 　　　　(3)提供了一些在GCD中不容易实现的特性，如：限制最大并发数量、操作之间的依赖关系

 　　3.GCD —— Grand Central Dispatch

 　　　　(1)是基于C语言的底层API

 　　　　(2)用Block定义任务，使用起来非常灵活便捷

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


3.  队列和线程的区别：

 队列：是管理线程的，相当于线程池,能管理线程什么时候执行。

  串行队列：队列中的线程按顺序执行（不会同时执行）

  并行队列：队列中的线程会并发执行，可能会有一个疑问，队列不是先进先出吗，如果后面的任务执行完了，怎么出去的了。这里需要强调下，任务执行完毕了，不一定出队列。只有前面的任务执行完了，才会出队列。

4.   主线程队列和GCD创建的队列也是有区别的。

  主线程队列和GCD创建的队列是不同的。在GCD中创建的队列优先级没有主队列高，所以在GCD中的串行队列开启同步任务里面没有嵌套任务是不会阻塞主线程，只有一种可能导致死锁，就是串行队列里，嵌套开启任务，有可能会导致死锁。

  主线程队列中不能开启同步，会阻塞主线程。只能开启异步任务，开启异步任务也不会开启新的线程，只是降低异步任务的优先级，让cpu空闲的时候才去调用。而同步任务，会抢占主线程的资源，会造成死锁。

5. 线程：里面有非常多的任务（同步，异步）

  同步与异步的区别：

  同步任务优先级高，在线程中有执行顺序，不会开启新的线程。

 异步任务优先级低，在线程中执行没有顺序，看cpu闲不闲。在主队列中不会开启新的线程，其他队列会开启新的线程。

6.  主线程队列注意：

  在主队列开启异步任务，不会开启新的线程而是依然在主线程中执行代码块中的代码。为什么不会阻塞线程？

   主队列开启异步任务，虽然不会开启新的线程，但是他会把异步任务降低优先级，等闲着的时候，就会在主线程上执行异步任务。 

 7. 在主队列开启同步任务，为什么会阻塞线程？

  在主队列开启同步任务，因为主队列是串行队列，里面的线程是有顺序的，先执行完一个线程才执行下一个线程，而主队列始终就只有一个主线程，主线程是不会执行完毕的，因为他是无限循环的，除非关闭应用程序。因此在主线程开启一个同步任务，同步任务会想抢占执行的资源，而主线程任务一直在执行某些操作，不肯放手。两个的优先级都很高，最终导致死锁，阻塞线程了。 

8.  串行队列开启异步任务后嵌套同步任务造成死锁

[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. - (void)serial_queue_deadlock  
  2.   
  3. {  
  4.     dispatch_queue_t q = dispatch_queue_create("cn.itcast.gcddemo", DISPATCH_QUEUE_SERIAL);  
  5.   
  6.     dispatch_async(q, ^{  
  7.    
  8.         NSLog(@"异步任务 %@", [NSThread currentThread]);  
  9.   
  10.         // 下面开启同步造成死锁：因为串行队列中线程是有执行顺序的，需要等上面开启的异步任务执行完毕，才会执行下面开启的同步任务。而上面的异步任务还没执行完，要到下面的大括号才算执行完毕，而下面的同步任务已经在抢占资源了，就会发生死锁。  
  11.   
  12.         dispatch_sync(q, ^{  
  13.             NSLog(@"同步任务 %@", [NSThread currentThread]);  
  14.         });  
  15.     });  
  16.   
  17. }  

  9. 串行队列开启同步任务后嵌套同步任务造成死锁

[objc] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. - (void)serial_queue_deadlock  
  2. {  
  3.     dispatch_queue_t q = dispatch_queue_create("cn.itcast.gcddemo", DISPATCH_QUEUE_SERIAL);  
  4.     dispatch_sync(q, ^{  
  5.         NSLog(@"同步任务 %@", [NSThread currentThread]);  
  6.         // 下面开启同步造成死锁：因为串行队列中线程是有执行顺序的，需要等上面开启的同步任务执行完毕，才会执行下面开启的同步任务。而上面的同步任务还没执行完，要到下面的大括号才算执行完毕，而下面的同步任务已经在抢占资源了，就会发生死锁。  
  7.         dispatch_sync(q, ^{  
  8.             NSLog(@"同步任务 %@", [NSThread currentThread]);  
  9.         });  
  10.    
  11.     });  
  12.   
  13.     NSLog(@"同步任务 %@", [NSThread currentThread]);  
  14. }  

阅读全文
0 0
淘宝网夏季竹凉席坐垫 淘宝网夏季竹凉席坐垫
原创粉丝点击
热门IT博客
sql 重复数据sql 重复数据
mac抹掉磁盘失败mac抹掉磁盘失败
淘宝如何创建企业店铺
阿里 腾讯 混合云
闪电网络是什么
阿里云华北3与华北2
手机写java代码的软件
京东商城app源码
郑州淘宝设计培训
mac修改locale
centos启动mysql服务
matlab矩阵添加一列
中文版电路板设计软件
js如何定义类
淘宝红包微信群
淘宝自动回复创意语句
淘宝怎么添加旺信
淘宝助请选择发货网点
纠正发音软件
疯狂的美工在线布局
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 脚指甲剪得太深怎么办 猫指甲剪出血了怎么办 指甲旁边的肉疼怎么办 猫指甲剪多了怎么办 宝宝指甲剪深了怎么办 指甲长在肉里面怎么办 门牙缺了一小块怎么办 婴儿指甲剪破了怎么办 狗狗指甲盖掉了怎么办 指甲切菜切掉了怎么办 指甲切到了很痛怎么办 刀把指甲切破了怎么办 手指被刀割伤了怎么办 胳膊被刀划伤了怎么办 剪刀磨了剪不动怎么办 如果剪子尖没了怎么办 电脑内网网速慢怎么办 手机4g网速太慢怎么办 手机4g网速慢怎么办 我的电脑网速慢怎么办 无线网网速太慢怎么办 新铁菜刀生锈了怎么办 被菜刀切到手指怎么办 手被菜刀切了怎么办 宝宝被开水烫了怎么办 手被开水烫红了怎么办 手背被开水烫了怎么办 脸被开水烫红了怎么办 被开水烫了该怎么办 被开水烫了起泡怎么办 手被割破了很深怎么办 手被刀子割破了怎么办 玻面砖太滑了怎么办 鞋子的鞋底好滑怎么办 新铺的瓷砖干滑怎么办 新买的拖鞋很滑怎么办 瓷砖地板刮花了怎么办 墙上瓷砖快掉了怎么办 香皂掉厕所堵了怎么办 陶瓷刀不锋利了怎么办 蒸馒头没有屉布怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里