码迷，mamicode.com
首页 > 其他好文 > 详细

完整详解GCD系列（一）dispatch_async;dispatch_sync;dispatch_async_f;dispatch_sync_f

时间：2014-11-14 06:56:03      阅读：310      评论：0      收藏：0      [点我收藏+]

标签：style   blog   http   io   color   ar   os   使用   sp   

为什么要写这个系列，因为百度了一下，找了很多都是些片面的Blog，拷贝来拷贝去的，写的也很粗糙。

所以，我要写这个系列，尽量把官网文档中GCD的强大功能完整的表达出来。方便自己，也方便别人，如果发现有问题，欢迎提出


本教程的计划：在完整的看过GCD的官方文档之后，我实在想不出来如何用一篇文章详细完整的写出来如此多的功能。
所以，决定开一个专栏来写这个教程。计划8篇文章，分别介绍各种功能，每种功能会附上简单完整的示例代码。最后

的一篇文章会进行总结，总结出GCD的经典使用场景。源代码只提供Swift版本。因为要上班，计划一个月内完成。每周两篇。


GCD
全称：Grand Central Dispatch 
简介：GCD是对多线程、多核开发较完整的封装。在使用GCD的时候，系统会自动根据CPU使用情况进行调度，所以GCD是
一个简单易用，但是效果很好地多线程多核开发工具。
要注意的地方：
1、慎用fork()函数（不是十分清楚流程不要用）
2、GCD是C语言级别的API，所以不会抓到异常，在一个提交到GCD的任务完成之前，应当处理完异常。


教程一
教程一涵盖了
1、GCD全局队列的四个优先级
2、几种本文使用到的GCD类型
3、dispatch_async/dispatch_async_f
4、dispatch_sync/dispatch_sync_f


一、概念与类型
对于GCD来说，所有的执行都放到队列中(queue)，队列的特点是FIFO（先提交的先执行）。
GCD的队列分为几种，主队列（main）,全局队列(global),用户创建队列(create)
对于全局队列，默认有四个，分为四个优先级

[cpp] view plaincopy
  1. #define DISPATCH_QUEUE_PRIORITY_HIGH         2  
  2. #define DISPATCH_QUEUE_PRIORITY_DEFAULT      0  
  3. #define DISPATCH_QUEUE_PRIORITY_LOW          (-2)  
  4. #define DISPATCH_QUEUE_PRIORITY_BACKGROUND   INT16_MIN  



DISPATCH_QUEUE_PRIORITY_HIGH :优先级最高，在default,和low之前执行
DISPATCH_QUEUE_PRIORITY_DEFAULT 默认优先级，在low之前，在high之后
DISPATCH_QUEUE_PRIORITY_LOW 在high和default后执行
DISPATCH_QUEUE_PRIORITY_BACKGROUND:提交到这个队列的任务会在high优先级的任务和已经提交到 background队列的执行完后执行。官方文档：(the queue is scheduled for execution after all high priority queues have been scheduled and the system runs items on a thread whose priority is set for background status.)


几种使用到的类型

[cpp] view plaincopy
  1. typealias dispatch_queue_t = NSObject //轻量级的用来描述执行任务的队列  
  2. typealias dispatch_block_t = () -> Void //队列执行的闭包(Objective C中的block)  


几个概念
异步 提交的任务立刻返回，在后台队列中执行
同步 提交的任务在执行完成后才会返回
并行执行（全局队列） 提交到一个队列的任务，比如提交了任务1和任务2，在任务1开始执行，并且没有执行完毕时候，任务2就可以开始执行。
串行执行（用户创建队列） 提交到一个队列中的任务，比如提交了任务1和任务2，只有任务1结束后，任务2才可执行

注意：提交到队列中的任务是串行执行，还是并行执行由队列本身决定。

二、示例详解

[plain] view plaincopy
  1. func dispatch_async(_ queue: dispatch_queue_t!,  
  2.                   _ block: dispatch_block_t!)  

参数：
queue 提交到的队列，队列的类型决定了是串行还是并行执行队列中的任务
block 执行的闭包

[plain] view plaincopy
  1. func dispatch_async_f(_ queue: dispatch_queue_t!,  
  2.                     _ context: UnsafeMutablePointer<Void>,  
  3.                     _ work: dispatch_function_t)  

参数
queue 提交到的队列，队列的类型决定了是串行还是并行执行队列中的任务
context 传递给work的参数

work 执行的函数(C语言函数)

dispatch_sync 和 dispatch_sync的参数和上述对应一致，所以不再列出

总得来说带有后缀_f(比如dispatch_sync_f，dispatch_after_f)就是提交给队列一个C语言函数，因为极少用到这种形式，这里仅给出一个简单例子，后面的涉及到_f的都略过。

1、dispatch_async/dispatch_sync
功能：提交到队列中异步/同步执行
本示例：下载一张图片，图片下载完毕后通知UI改变
注意：要改变UI必须在主队列上执行
这里用到了一个获取全局队列的函数

[plain] view plaincopy
  1. func dispatch_get_global_queue(_ identifier: Int,  
  2.                              _ flags: UInt) -> dispatch_queue_t!  

这个函数的第一个参数是队列的优先级，第二个参数尚没有意义，直接写0就可以了。

创建一个基于单页面的Swift工程，然后在ViewController.swift中，

[plain] view plaincopy
  1. class ViewController: UIViewController{    
  2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))    
  3.     override func viewDidLoad(){    
  4.         super.viewDidLoad()    
  5.         imageview.contentMode = UIViewContentMode.ScaleAspectFit    
  6.         self.view.addSubview(imageview)    
  7.         let url = "http://f.hiphotos.baidu.com/image/pic/item/e1fe9925bc315c60191d32308fb1cb1348547760.jpg"    
  8.         let imageURL = NSURL(string:url)     
  9.     var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)  
  10.     dispatch_async(globalQueueDefault){  
  11.         var imageData = NSData(contentsOfURL:imageURL!)  
  12.         var image = UIImage(data:imageData!)  
  13.         if let successfulImage = image{  
  14.             sleep(2)  
  15.             dispatch_async(dispatch_get_main_queue()){  
  16.                 self.imageview.image = successfulImage  
  17.             }  
  18.         }  
  19.     }  
  20.     }    
  21.     override func didReceiveMemoryWarning(){    
  22.         super.didReceiveMemoryWarning()    
  23.     }    
  24. }    

执行，观察下效果：view立刻载入，然后过一段时间，图片下载完了，UI改变
然后，我们观察dispatch_sync
只需要修改这一行即可

[plain] view plaincopy
  1. dispatch_sync(globalQueueDefault,0){  


执行，观察下效果：view载入很慢，但是在载入的时候，图片下载完了。UI已经改变。可以打在这一行打断点，会发现异步执行会立刻返回，同步执行会等待执行结束后返回。
所以，当我们有一件非常耗时的事情，放到后台队列中去做，等做完了通知UI改变，是不会阻塞UI，降低用户体验的。


2、dispatch_async_f/dispatch_sync_f
简单的实例，把一个C函数提交给队列
首先，建立一个基于单页面的swift工程,命名为testForCSDN，然后再新建一个C语言文件，命名为hwcText->点击包括头文件->点击包含Bridging-Header.h
这样，工程里多了三个文件
hwcTest.c
hwcTest.h
testForCSDN-Bridging-Header.h
附上完整的代码
testForCSDN-Bridging-Header.h

[cpp] view plaincopy
  1. #import "hwcTest.h"  


hwcTest.h

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <unistd.h>  
  3. typedef void (*hwcTestForGCD)(void*);  
  4. hwcTestForGCD getFuncPointer();  


hwcTest.c

[cpp] view plaincopy
  1. #include "hwcTest.h"  
  2. void realFunction(void *input){  
  3.     for(int i = 0;i < 5;i++){  
  4.         printf("%d\n",i);  
  5.         sleep(1);  
  6.     }  
  7. }  
  8. hwcTestForGCD getFuncPointer(){  
  9.     return realFunction;  
  10. }  

ViewController.swift

[plain] view plaincopy
  1. class ViewController: UIViewController{    
  2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))    
  3.     override func viewDidLoad(){    
  4.         super.viewDidLoad()    
  5.         var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)  
  6.     dispatch_async_f(globalQueueDefault,nil,getFuncPointer())  
  7.     println("dispatch is over")  
  8.     }    
  9.     override func didReceiveMemoryWarning(){    
  10.         super.didReceiveMemoryWarning()    
  11.     }    
  12. }   

然后执行，会发现输出

[plain] view plaincopy
  1. 0  
  2. dispatch is over  
  3. 1  
  4. 2  
  5. 3  
  6. 4  


然后，我们同样改成dispatch_sync后执行，发现输出

[plain] view plaincopy
  1. 0  
  2. 1  
  3. 2  
  4. 3  
  5. 4  
  6. 5  
  7. dispatch is over  

这里更能体会到了，什么是同步，什么是异步了吧。


三、理解下并行队列和串行队列
使用一或者二中的工程都可以，修改ViewController.swft中的代码就可以
这里用到了一个函数

[plain] view plaincopy
  1. func dispatch_queue_create(_ label: UnsafePointer<Int8>,  
  2.                          _ attr: dispatch_queue_attr_t!) -> dispatch_queue_t!  

参数
label String类型的队列标示符，通常取做com.companyname.productname.functionname
attr   两种类型。DISPATCH_QUEUE_SERIAL创建一个顺序执行队列， DISPATCH_QUEUE_CONCURRENT创建同时执行队列


ViewController的完整代码，这里提交两个任务，通过输出来判断是并行队列，还是串行队列

[plain] view plaincopy
  1. class ViewController: UIViewController{    
  2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))    
  3.     override func viewDidLoad(){    
  4.         super.viewDidLoad()   
  5.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){  
  6.         for var i = 0;i < 5;i++ {  
  7.             NSLog("First task:%d",i)  
  8.             sleep(1)  
  9.         }  
  10.     }  
  11.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){  
  12.         for var j = 0;j < 5;j++ {  
  13.             NSLog("Second task:%d",j)  
  14.             sleep(1)  
  15.         }  
  16.     }  
  17.     println("dispatch is over")  
  18.     }    
  19.     override func didReceiveMemoryWarning(){    
  20.         super.didReceiveMemoryWarning()    
  21.     }    
  22. }   

这里执行输出为：

[plain] view plaincopy
  1. First task:0  
  2. Second task:0  
  3. First task:1  
  4. Second task:1  
  5. First task:2  
  6. Second task:2  
  7. First task:3  
  8. Second task:3  
  9. First task:4  
  10. Second task:4  

这段代码执行时间4.03s


然后，我们使用串行执行的队列

[plain] view plaincopy
  1. class ViewController: UIViewController{    
  2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))    
  3.     override func viewDidLoad(){    
  4.         super.viewDidLoad()  
  5.     var serialQueue =  dispatch_queue_create(label:   
  6.   
  7.   
  8. "com.test.helloHwc",attr:DISPATCH_QUEUE_SERIAL)  
  9.     dispatch_async(serialQueue){  
  10.         for var i = 0;i < 5;i++ {  
  11.             NSLog("First task:%d",i)  
  12.             sleep(1)  
  13.         }  
  14.     }  
  15.     dispatch_async(serialQueue){  
  16.         for var j = 0;j < 5;j++ {  
  17.             NSLog("Second task:%d",j)  
  18.                         sleep(1)  
  19.         }  
  20.     }  
  21.     println("dispatch is over")  
  22.     }    
  23.     override func didReceiveMemoryWarning(){    
  24.         super.didReceiveMemoryWarning()    
  25.     }    
  26. }   

这里输出为

[plain] view plaincopy
    1. First task:0  
    2. First task:1  
    3. First task:2  
    4. First task:3  
    5. First task:4  
    6. Second task:0  
    7. Second task:1  
    8. Second task:2  
    9. Second task:3  
    10. Second task:4 

完整详解GCD系列（一）dispatch_async;dispatch_sync;dispatch_async_f;dispatch_sync_f

标签：style   blog   http   io   color   ar   os   使用   sp   

原文地址：http://www.cnblogs.com/lkda992/p/4096346.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！